task.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_cc4a6c5e5e2c6e084fa5b97911783920c4c9c1fc5b484939dbc7448e7ebcb559
#define USGOV_cc4a6c5e5e2c6e084fa5b97911783920c4c9c1fc5b484939dbc7448e7ebcb559
 
#include <unordered_map>
#include <string>
#include <cassert>
#include <thread>
#include <mutex>
#include <vector>
#include <fstream>
#include <chrono>
#include <sstream>
#include <sys/types.h>
#include <atomic>
#include <unistd.h>
#include <iostream>
 
namespace us { namespace dbg {
    using namespace std;
    using namespace chrono;
 
    struct thread_logger;
 
    struct task final {
        task(thread_logger&l);
        ~task();
 
        void start(const string&dir, const string&name);
        static bool start(ostream*&, const thread_logger&, const string& dir, const string&name, short g);
 
        template<typename type1>
        void dolog(const type1& arg1) {
            *logfile << arg1 << ' ';
            if (teecout) std::cout << arg1 << ' ';
        }
 
        template<typename type1, typename... types>
        void dolog(const type1& arg1, const types& ... args) {
            dolog(arg1);
            dolog(args...);
        }
 
        static void prefix(ostream&, const thread_logger&, const string&log_level_, const string& log_class_);
 
        template<typename... Args>
        void log(const string&log_level, const string& log_class, const Args&... args) {
            if (onduty) return; //operator << can trigger recursive log calls which we ignore
            if (logfile==0) start("","unknown");
            onduty=true;
            prefix(*logfile,logger,log_level,log_class);
            if (teecout) prefix(std::cout,logger,log_level,log_class);
            dolog(args...);
            onduty=false;
            *logfile << endl;
            if (teecout) std::cout << endl;
        }
 
        template<typename O>
        void logdump(const string&log_level, const string&log_class, const O& o) {
            if (onduty) return;
            ostringstream pfx;
            prefix(pfx,logger,log_level,log_class);
            o.dump(pfx.str(),*logfile);
            if (teecout) {
                o.dump(pfx.str(),std::cout);
            }
        }
 
        template<typename O>
        void logdump(const string&log_level, const string&log_class, const string&logpfx, const O& o) {
            if (onduty) return;
            ostringstream pfx;
            prefix(pfx,logger,log_level,log_class);
            string spfx=pfx.str()+logpfx;
            o.dump(spfx,*logfile);
            if (teecout) {
                o.dump(spfx,std::cout);
            }
        }
 
        bool onduty{false};
        void log_stacktrace() const;
        static bool verbose; //false (def): logs go to file; true: logs go to cout
        ostream* logfile{0};
        bool ownlogfile{true};
        const thread_logger& logger;
        static string pname;
        static bool teecout;
        static string logdir;
        short g{0};
    };
 
    template<>
    void task::dolog(const vector<unsigned char>& arg1);
 
}}
 
#endif