Logger.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsUtils/Globals.h>
#include <sstream>
#include <memory>
#include <AtomsUtils/AtomsMath.h>
 
namespace AtomsUtils
{
 
 
    class ATOMSUTILS_EXPORT LogType
    {
    public:
        enum MessageType
        {
            kINFO,
            kWARNING,
            kERROR,
            kCOMMAND
        };
 
        LogType();
 
        virtual ~LogType();
 
        void flushMessage(MessageType mType, const std::string &msg);
 
        virtual void info(const std::string &msg);
 
        virtual void warning(const std::string &msg);
 
        virtual void error(const std::string &msg);
 
        virtual void cmd(const std::string &msg);
 
    };
 
    class ATOMSUTILS_EXPORT LogProxy
    {
    public:
 
        LogProxy(LogType* l, LogType::MessageType mType);
 
        LogProxy(const LogProxy &other);
 
        ~LogProxy();
 
#ifdef ATOMS_UNREAL
        LogProxy& operator<<(const std::string& value);
        LogProxy& operator<<(const char* value);
        LogProxy& operator<<(const double value);
        LogProxy& operator<<(const int value);
        LogProxy& operator<<(const unsigned int value);
#ifndef ATOMS_32
        LogProxy& operator<<(const size_t value);
#endif
        LogProxy& operator<<(const bool value);
 
        LogProxy& operator<<(const float value);
        LogProxy& operator<<(const short value);
        LogProxy& operator<<(const unsigned short value);
        LogProxy& operator<<(const long value);
 
        LogProxy& operator<<(const AtomsMath::Vector2& value);
        LogProxy& operator<<(const AtomsMath::Vector2f& value);
        LogProxy& operator<<(const AtomsMath::Vector3& value);
        LogProxy& operator<<(const AtomsMath::Vector3f& value);
        LogProxy& operator<<(const AtomsMath::Vector4& value);
        LogProxy& operator<<(const AtomsMath::Vector4f& value);
        LogProxy& operator<<(const AtomsMath::Matrix& value);
        LogProxy& operator<<(const AtomsMath::Matrixf& value);
        LogProxy& operator<<(const AtomsMath::Quaternion& value);
        LogProxy& operator<<(const AtomsMath::Quaternionf& value);
        LogProxy& operator<<(const AtomsMath::Euler& value);
        LogProxy& operator<<(const AtomsMath::Eulerf& value);
 
#else
        template<typename T>
        inline LogProxy& operator<<(const T& value)
        {
            m_msg << value << " ";
            return *this;
        }
#endif
 
    private:
 
        std::stringstream m_msg;
 
        LogType::MessageType m_mType;
 
        LogType* m_logType;
    };
 
    class ATOMSUTILS_EXPORT Logger
    {
    public:
 
        Logger();
 
 
        void setLogType(std::shared_ptr<LogType>& logType);
 
        std::shared_ptr<LogType> logType();
 
        static Logger& instance();
 
        static LogProxy log(LogType::MessageType mType);
 
        static LogProxy info();
 
        static LogProxy warning();
 
        static LogProxy error();
 
        static LogProxy cmd();
 
    private:
 
        ~Logger();
 
        Logger(const Logger&);
 
        Logger& operator=(const Logger&);
 
    private:
 
        std::shared_ptr<LogType> m_logType;
    };
#ifndef ATOMS_UNREAL
    template<>
    inline LogProxy& LogProxy::operator<<(const AtomsMath::Matrix& value)
    {
        m_msg << "( "<< value[0][0] << ", " << value[0][1] << ", " << value[0][2] << ", " << value[0][3] << ", ";
        m_msg << value[1][0] << ", " << value[1][1] << ", " << value[1][2] << ", " << value[1][3] << ", ";
        m_msg << value[2][0] << ", " << value[2][1] << ", " << value[2][2] << ", " << value[2][3] << ", ";
        m_msg << value[3][0] << ", " << value[3][1] << ", " << value[3][2] << ", " << value[3][3] << " ) ";
        return *this;
    }
 
    template<>
    inline LogProxy& LogProxy::operator<<(const AtomsMath::Matrixf& value)
    {
        m_msg << "( " << value[0][0] << ", " << value[0][1] << ", " << value[0][2] << ", " << value[0][3] << ", ";
        m_msg << value[1][0] << ", " << value[1][1] << ", " << value[1][2] << ", " << value[1][3] << ", ";
        m_msg << value[2][0] << ", " << value[2][1] << ", " << value[2][2] << ", " << value[2][3] << ", ";
        m_msg << value[3][0] << ", " << value[3][1] << ", " << value[3][2] << ", " << value[3][3] << " ) ";
        return *this;
    }
#endif
}