LogHookManager.h

Go to the documentation of this file.

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//

#ifndef CMR_LOG_HOOK_MANAGER_INCLUDED
#define CMR_LOG_HOOK_MANAGER_INCLUDED

#include "commore/AutoRef.h"
#include "commore/Error.h"
#include "commore/LogHook.h"


namespace commore
{
    //
    // The unique log hook manager (internal commore class)
    //
    class LogHookManager
    {
    private:
        LogHookManager(const LogHookManager&);
        LogHookManager& operator = (const LogHookManager&);
        // LogHookManager is a singleton
        LogHookManager() : ok_(true), busy_(false)
        {
        }

    public:
        //
        bool ok_;
        bool busy_;
        List<LogHook*> hook_list_;
        static   CriticalSection cs_;

        ~LogHookManager()
        {
            ok_ = false;
        }
        static LogHookManager& get_instance()
        {
            static LogHookManager log_hook_manager_;
            return log_hook_manager_;
        }

        //
        // Reentrance protection
        //
        bool check_free(bool busy)
        {
            bool r = false;
            Lock lock(cs_);
            if (busy)
            {
                r = !busy_;
                if (!busy_)
                {
                    busy_ = true;
                }
            }
            else
            {
                if (busy_)
                {
                    busy_ = false;
                }
            }
            return r;
        }

        bool add(LogHook* hook)
        {
            bool r = false;
            if (ok_)
            {
                //
                // Add once
                //
                Lock lock(cs_);
                if (!hook->hooked_)
                {
                    hook->hooked_ = true;
                    hook_list_.push_back(hook);
                    r = true;
                }
            }
            return r;
        }
        bool remove(LogHook* hook)
        {
            bool r = false;
            if (ok_)
            {
                Lock lock(cs_);
                r = hook->hooked_;
                hook->hooked_ = false;
                hook_list_.remove(hook);
            }
            return r;
        }
        //
        // Return true if list is not empty
        //
        bool get_hook_list(List<PLogHook>& hook_list)
        {
            int r = 0;
            Lock lock(cs_);
            for (List<LogHook*>::iterator i = hook_list_.begin(); i; i++)
            {
                hook_list.add(*i);
                r++;
            }
            return r > 0;
        }
        void dispatch(Tuple& message);

    };

}


#endif