Log.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Graph/Dep.h"
#include "Honey/Thread/Lock/Spin.h"

namespace honey
{

#define Log_debug               Log::inst() << log::level::debug << "[" << log::srcFilename(__FILE__) << ":" << __LINE__ << "] "

namespace log
{
    typedef DepNode<void*, NameId> Level;
    
    namespace level
    {
        extern Level critical;  
        extern Level error;     
        extern Level warning;   
        extern Level info;      
        extern Level debug;     
    }
    
    String format(const Level& level, const String& record);
    
    struct Sink : SharedObj<Sink>
    {
        typedef SharedPtr<Sink> Ptr;
        
        virtual void operator()(const Level& level, const String& record) = 0;
    };
    
    struct BufferSink : Sink
    {
        typedef SharedPtr<BufferSink> Ptr;
        
        virtual void operator()(const Level& level, const String& record);
        vector<tuple<const Level*, String>> records;
    };
    
    struct StreamSink : Sink
    {
        typedef SharedPtr<StreamSink> Ptr;
        
        StreamSink(ostream& os)                 : os(os) {}
        virtual void operator()(const Level& level, const String& record);
        ostream& os;
    };
    
    struct FileSink : StreamSink
    {
        typedef SharedPtr<FileSink> Ptr;
        
        FileSink(String filepath);
        ~FileSink();
        virtual void operator()(const Level& level, const String& record);
        String filepath;
        std::ofstream os;
    };
    
    inline String srcFilename(const String& path)       { szt pos = path.find_last_of(String("\\/")); return pos != String::npos ? path.substr(pos+1) : path; }
}

class Log
{
public:
    typedef DepGraph<const log::Level> LevelGraph;
    typedef unordered_map<Id, log::Sink::Ptr> SinkMap;
    
    struct RecordStream : ostringstream
    {
        RecordStream(Log& log, const log::Level& level) : log(&log), lock(log._lock) { log._level = &level; }
        RecordStream(RecordStream&& rhs)                : ostringstream(std::move(rhs)), log(rhs.log), lock(std::move(rhs.lock)) { rhs.log = nullptr; }
        ~RecordStream()                                 { if (!log) return; log->push(str()); }
        Log* log;
        SpinLock::Scoped lock;
    };
    
    static mt_global(Log, inst,);

    Log();
    
    void addLevel(const log::Level& level);
    void removeLevel(const log::Level& level);
    const LevelGraph& levels() const                    { return _levelGraph; }
    
    void addSink(const Id& name, const log::Sink::Ptr& sink);
    void removeSink(const Id& name);
    const SinkMap& sinks() const                        { return _sinks; }
    

    void filter(const Id& sink, const vector<const log::Level*>& includes, bool includeDeps = true,
                const vector<const log::Level*>& excludes = {}, bool excludeDeps = true);
    void clearFilter(const Id& sink);
    
    RecordStream operator<<(const log::Level& level)    { return RecordStream(*this, level); }
    
    SpinLock::Scoped lock()                             { return _lock; }
    
private:
    typedef unordered_map<Id, std::set<Id>> FilterMap;

    void push(const String& record);
    
    LevelGraph _levelGraph;
    const log::Level* _level;
    SinkMap _sinks;
    FilterMap _filters;
    SpinLock _lock;
};

}