Logger.hpp

#pragma once
#ifndef __H__OCULAR_LOGGER__H__
#define __H__OCULAR_LOGGER__H__

#include "ILoggerListener.hpp"
#include "Exceptions/Exception.hpp"

#include <list>
#include <sstream>
#include <memory>
#include <mutex>

//------------------------------------------------------------------------------------------

namespace Ocular 
{
    namespace Core
    {
        class Logger
        {
        public:

            Logger();

            ~Logger();

            void registerListener(ILoggerListener* listener);

            template<typename T, typename... U>
            void debug(T first, U... args)
            {
                m_Mutex.lock();

                m_CurrentMessage.channel = LoggerChannels::Debug;
                m_IncompleteMessage.str(std::string());
                m_IncompleteMessage << first;
                log(args...);

                m_Mutex.unlock();
            }

            template<typename T, typename... U>
            void info(T first, U... args)
            {
                m_Mutex.lock();

                m_CurrentMessage.channel = LoggerChannels::Info;
                m_IncompleteMessage.str(std::string());
                m_IncompleteMessage << first;
                log(args...);

                m_Mutex.unlock();
            }

            template<typename T, typename... U>
            void warning(T first, U... args)
            {
                m_Mutex.lock();

                m_CurrentMessage.channel = LoggerChannels::Warning;
                m_IncompleteMessage.str(std::string());
                m_IncompleteMessage << first;
                log(args...);

                m_Mutex.unlock();
            }

            template<typename T, typename... U>
            void error(T first, U... args)
            {
                m_Mutex.lock();

                m_CurrentMessage.channel = LoggerChannels::Error;
                m_IncompleteMessage.str(std::string());
                m_IncompleteMessage << first;
                log(args...);

                m_Mutex.unlock();
            }

            void error(Exception& e);

            template<typename T, typename... U>
            void fatal(T first, U... args)
            {
                m_Mutex.lock();

                m_CurrentMessage.channel = LoggerChannels::Fatal;
                m_IncompleteMessage.str(std::string());
                m_IncompleteMessage << first;
                log(args...);

                m_Mutex.unlock();
            }
        
        protected:

        private:

            template<typename T, typename... U>
            void log(T first, U... last)
            {
                m_IncompleteMessage << first;
                log(last...);
            }

            void log();

            //--------------------------------------------

            std::stringstream m_IncompleteMessage;
            LoggerMessage m_CurrentMessage;

            std::list<std::unique_ptr<ILoggerListener>> m_Listeners;

            std::mutex m_Mutex;

        };
    }
}
//------------------------------------------------------------------------------------------

#endif