ContextBase.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_CONTEXTBASE
#define H_POTTU_CONTEXTBASE
 
#include <fmt/base.h>
#include <fmt/chrono.h>
#include <fmt/color.h>
 
#include <string>
#include <iostream>
#include <chrono>
#include <memory>
#include <vector>
 
#include <mutex>
 
 
namespace pottu {
 
    enum loggerlevel_e {
    LOGLEVEL_NONE     = 0,
    LOGLEVEL_DEBUG    = 10,
    LOGLEVEL_INFO     = 20,
    LOGLEVEL_WARNING  = 30,
    LOGLEVEL_ERROR    = 40,
    LOGLEVEL_CRITICAL = 50
    };
 
 
    class ContextHandle;
 
 
    struct ContextBase {
 
    static void registerContext( ContextBase *context ) {
        const std::lock_guard<std::mutex> lock(_getMutex());
        std::unique_ptr<ContextBase> &ctx = _getActiveRef();
        if( ctx )
        throw std::runtime_error( "Context is already registered." );
        ctx.reset( context );
    }
 
    // PRIVATE
    static std::mutex &_getMutex() noexcept {
        static std::mutex m;
        return m;
    }
        
    // PRIVATE
    static std::unique_ptr<ContextBase> &_getActiveRef() noexcept { 
        static std::unique_ptr<ContextBase> ctx;
        return ctx;
    }
 
    
    static ContextBase &getActive() noexcept {
        const std::lock_guard<std::mutex> lock(_getMutex());
        std::unique_ptr<ContextBase> &ctx = _getActiveRef();
        if( !ctx )
        ctx.reset( new ContextBase() );
        return *ctx.get();
    }
    
    
    inline ContextHandle *createHandle( const std::string &name ) noexcept;
    
    
    const char *loglevelToStr( uint8_t level ) const noexcept {
        if( level < LOGLEVEL_DEBUG )
        return "none";
        else if( level < LOGLEVEL_INFO )
        return "debug";
        else if( level < LOGLEVEL_WARNING )
        return "info";
        else if( level < LOGLEVEL_ERROR )
        return "warning";
        else if( level < LOGLEVEL_CRITICAL )
        return "error";
        else
        return "critical";
    }
 
    const fmt::text_style &getStyleForLevel( uint8_t level ) const noexcept {
        if( level < LOGLEVEL_DEBUG )
        return styles[0];
        else if( level < LOGLEVEL_INFO )
        return styles[1];
        else if( level < LOGLEVEL_WARNING )
        return styles[2];
        else if( level < LOGLEVEL_ERROR )
        return styles[3];
        else if( level < LOGLEVEL_CRITICAL )
        return styles[4];
        else
        return styles[5];
    }
 
    static void logDebug( const std::string &message, uint64_t token=0 )    {
        getActive().handleLogMsg( "", LOGLEVEL_DEBUG, message );
    }
    static void logInfo( const std::string &message, uint64_t token=0 )     {
        getActive().handleLogMsg( "", LOGLEVEL_INFO, message );
    }
    static void logWarning( const std::string &message, uint64_t token=0 )  {
        getActive().handleLogMsg( "", LOGLEVEL_WARNING, message );
    }
    static void logError( const std::string &message, uint64_t token=0 )    {
        getActive().handleLogMsg( "", LOGLEVEL_ERROR, message );
    }
    static void logCritical( const std::string &message, uint64_t token=0 ) {
        getActive().handleLogMsg( "", LOGLEVEL_CRITICAL, message );
    }
 
    
    inline void printStatistics() noexcept;
 
    virtual void handleLogMsg( const std::string &sender, uint8_t level, const std::string &message ) noexcept {
        const std::lock_guard<std::mutex> lock(_getMutex());
        auto t = std::chrono::system_clock::now();
        if( useStyles ) {
        fmt::print( getStyleForLevel(level), "{:12} {:10} {:%H:%M:%S} {:4}", sender, loglevelToStr(level), t, message );
        fmt::print( "\n" );
        } else
        fmt::print( "{:12} {:10} {:%H:%M:%S} {:4}\n", sender, loglevelToStr(level), t, message );
    }
 
 
 
    bool useStyles{true};
    fmt::text_style styles[6] = {
        {fg(fmt::color::gray)},
        {fg(fmt::color::gray)},
        {},
        {fmt::emphasis::bold | bg(fmt::color::black) | fg(fmt::color::yellow)},
        {fg(fmt::color::red)},
        {fmt::emphasis::bold | fg(fmt::color::red)}
    };
 
    std::vector<std::unique_ptr<ContextHandle>>  _handles;
 
    };
 
 
 
    class ContextHandle {
    public:
    ContextHandle( ContextBase &ctx, const std::string &name ) : _ctx(ctx), _name(name) {}
 
    void logDebug( const std::string &message, uint64_t token=0 )    { _ctx.handleLogMsg( _name, LOGLEVEL_DEBUG,    message ); }
    void logInfo( const std::string &message, uint64_t token=0 )     { _ctx.handleLogMsg( _name, LOGLEVEL_INFO,     message ); }
    void logWarning( const std::string &message, uint64_t token=0 )  { _ctx.handleLogMsg( _name, LOGLEVEL_WARNING,  message ); }
    void logError( const std::string &message, uint64_t token=0 )    { _ctx.handleLogMsg( _name, LOGLEVEL_ERROR,    message ); }
    void logCritical( const std::string &message, uint64_t token=0 ) { _ctx.handleLogMsg( _name, LOGLEVEL_CRITICAL, message ); }
 
    const std::string &getName() const noexcept { return _name; }
    
    double getTotalRunTime() const noexcept { return ( std::chrono::duration<double>( _runsDuration ) ).count(); }
    uint64_t getNumOfRuns() const noexcept { return _runsFinished; }
    
    class ProcessInstance {
    public:
        ~ProcessInstance() { if( _h ) _h->stopProcess(); }
        ProcessInstance( ProcessInstance &&o ) : _h(o._h) { o._h = nullptr; }
    private:
        friend class ContextHandle;
        ProcessInstance( ContextHandle *h ) : _h(h) { _h->startProcess(); }
        ProcessInstance( const ProcessInstance &o ) = delete;
    
        ContextHandle *_h;
    };
    
    ProcessInstance processInstance() noexcept {
        return ProcessInstance( this );
    }
 
    private:
    friend class ProcessInstance;
    
    void startProcess() noexcept {
        _running = true;
        _runStart = std::chrono::steady_clock::now();
    }
 
    void stopProcess() noexcept {
        _running = false;
        ++_runsFinished;
        const auto t = std::chrono::steady_clock::now();
        _runsDuration += t-_runStart;
    }
 
    ContextBase                          &_ctx;
    std::string                           _name;
 
    bool                                  _running{false};
    uint64_t                              _runsFinished{0};
    std::chrono::steady_clock::duration   _runsDuration{std::chrono::steady_clock::duration(0)};
    std::chrono::steady_clock::time_point _runStart;
    };
 
 
 
 
    
    inline ContextHandle *ContextBase::createHandle( const std::string &name ) noexcept {
    const std::lock_guard<std::mutex> lock(_getMutex());
    // TODO multiple handles with same name
    
    _handles.push_back( std::make_unique<ContextHandle>( *this, name ) );
    return _handles.back().get();
    }
 
 
    inline void ContextBase::printStatistics() noexcept {
    std::string msg;
    {
        const std::lock_guard<std::mutex> lock(_getMutex());
        msg += fmt::format( "Statistics collected:\n" );
        msg += fmt::format( "  name                runs   time [s]\n" );
        for( const auto &h : _handles ) {
        if( h->getNumOfRuns() )
            msg += fmt::format("  {:32} {:12} {:10.3f}\n", h->getName(), h->getNumOfRuns(), h->getTotalRunTime() );
        }
 
        // Opening the mutex to avoid a dead lock.
    }
    handleLogMsg( "Context", LOGLEVEL_INFO, msg );
    }
 
    
}
 
 
#endif