logmaster.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************

#ifndef __logmaster_hpp__
#define __logmaster_hpp__

// Standard libraries
#include <string>
#include <set>
#include <map>
#include <vector>
#include <deque>
#include <fstream>
#include <chrono>
#include <omp.h>

// Gambit
#include "gambit/Logs/logger.hpp"
#include "gambit/Logs/log_tags.hpp"

namespace Gambit
{

  namespace Logging
  {
    struct Message;
    class BaseLogger;

    class LogMaster
    {
       public:
        LogMaster();

        LogMaster(std::map<std::set<int>,BaseLogger*>&);

        ~LogMaster();

        void init_memory();

        // This is the function that yaml_parser.hpp uses. You provide tags as a set of strings, and the filename as a string. We then construct the logger objects in here.
        // This needs to be a vector of pairs rather than a map in case people want duplicate output streams of certain logs. In this case there will be duplicate keys, which a map cannot allow.
        void initialise(std::vector<std::pair< std::set<std::string>, std::string>>&);

        // Overload to allow using maps as input
        void initialise(std::map<std::set<std::string>, std::string>&);

        // Overload of initialise function to allow easier manual initialisation in standalone modules
        void initialise(std::map<std::string, std::string>&);

        // Function to silence all log messages
        void disable();
        // Function to check if all log messages are silenced
        bool disabled();
        // Turn logs back on
        void enable();

        void emit_backlog(bool verbose);

        void input(const std::string&);
        void input(const LogTag&);
        void input(const endofmessage&);
        // Overloads for stream manipulators (typedefs in logger.hpp)
        void input(const manip1);
        void input(const manip2);
        void input(const manip3);

        // Need a bunch of overloads of this to deal with
        void send(const std::string&);
        void send(const std::string&,LogTag);
        void send(const std::string&,LogTag,LogTag);
        void send(const std::string&,LogTag,LogTag,LogTag);
        void send(const std::string&,LogTag,LogTag,LogTag,LogTag);
        void send(const std::string&,LogTag,LogTag,LogTag,LogTag,LogTag);
        //...add more as needed

        // stringstream versions of the above
        void send(const std::ostringstream&);
        void send(const std::ostringstream&,LogTag);
        void send(const std::ostringstream&,LogTag,LogTag);
        void send(const std::ostringstream&,LogTag,LogTag,LogTag);
        void send(const std::ostringstream&,LogTag,LogTag,LogTag,LogTag);
        void send(const std::ostringstream&,LogTag,LogTag,LogTag,LogTag,LogTag);
        //...add more as needed

        void send(const std::string&, std::set<LogTag>&);
        void send(const std::string&, std::set<int>&);
        void finalsend(const Message&);

        // stringstream versions...
        void send(const std::ostringstream&, std::set<LogTag>&);
        void send(const std::ostringstream&, std::set<int>&);

        void entering_module(int);
        void leaving_module();
        void entering_backend(int);
        void leaving_backend();


        void set_log_debug_messages(bool flag) {log_debug_messages=flag;}


      private:
        void empty_backlog();

        std::map<std::set<int>,BaseLogger*> loggers;

        std::set<int> ignore;

        bool loggers_readyQ;

        bool silenced;

        bool separate_file_per_process;

        bool log_debug_messages;

        int MPIrank;
        int MPIsize;

        int globlMaxThreads;


        int* current_module;  // index -1 means "not in any module"
        int* current_backend; // index -1 means "not in any backend"

        std::ostringstream* stream;
        std::set<int>* streamtags;

        std::deque<Message>* backlog;

    };

  } //end namespace Logging

} // end namespace Gambit

#endif