logger.hpp

#ifndef QOS_CPP_LOGGER
#define QOS_CPP_LOGGER
 
#include "include/types.hpp"
#include "include/util.hpp"
#include "include/clock.hpp"
#include "include/task.hpp"
#include "include/fsm.hpp"
#include "include/timer.hpp"
#include "include/input.hpp"
#include "config/config.h"
 
namespace qOS {
 
    #ifdef DOXYGEN
        class logger final {
            public:
                static logger& out( const logSeverity s );
                static logger& var( const void &v );
        };
    #endif
 
    namespace logger {
 
        struct source_location {
            public:
            #if not defined(__apple_build_version__) and defined(__clang__) and (__clang_major__ >= 9)
                static constexpr source_location current(const char* fileName = __builtin_FILE(),
                    const char* functionName = __builtin_FUNCTION(),
                    const unsigned long lineNumber = __builtin_LINE(),
                    const unsigned long columnOffset = __builtin_COLUMN() ) noexcept
            #elif defined(__GNUC__) and (__GNUC__ > 4 or (__GNUC__ == 4 and __GNUC_MINOR__ >= 8))
                static constexpr source_location current(const char* fileName = __builtin_FILE(),
                    const char* functionName = __builtin_FUNCTION(),
                    const unsigned long lineNumber = __builtin_LINE(),
                    const unsigned long columnOffset = 0 ) noexcept
            #else
                static constexpr source_location current(const char* fileName = "unsupported",
                    const char* functionName = "unsupported",
                    const unsigned long lineNumber = __LINE__,
                    const unsigned long columnOffset = 0) noexcept
            #endif
                {
                    return source_location( fileName, functionName, lineNumber, columnOffset ); // skipcq: CXX-W2033
                }
 
                source_location( const source_location & ) = default;
                source_location( source_location && ) = default;
 
                constexpr const char* file_name( void ) const noexcept
                {
                    return fileName;
                }
 
                constexpr const char* function_name( void ) const noexcept
                {
                    return functionName;
                }
 
                constexpr unsigned long line( void ) const noexcept
                {
                    return lineNumber;
                }
 
                constexpr unsigned long column( void ) const noexcept
                {
                    return columnOffset;
                }
 
            private:
                constexpr source_location( const char* FileName, const char* FunctionName, const unsigned long LineNumber, const unsigned long ColumnOffset ) noexcept
                    : fileName(FileName), functionName(FunctionName), lineNumber(LineNumber), columnOffset(ColumnOffset) {}
 
                const char* fileName;
                const char* functionName;
                const unsigned long lineNumber; // skipcq: CXX-W2010
                const unsigned long columnOffset; // skipcq: CXX-W2010
        };
 
        class lout_base final {
            public:
                uint8_t base;
                explicit lout_base(uint8_t b) : base(b) {}
        };
        enum logSeverity {
            none = 0,
            fatal = 1,
            error = 2,
            warning = 3,
            info = 4,
            debug = 5,
            verbose = 6,
        };
 
        class mem final {
            public:
                size_t n;
                explicit mem( size_t nb ) : n( nb ) {}
        };
 
        class pre final {
            public:
                uint8_t precision;
                explicit pre( uint8_t p ) : precision( p ) {}
        };
 
        extern const lout_base dec;
        extern const lout_base hex;
        extern const lout_base oct;
        extern const lout_base bin;
        extern const char * const endl;
        extern const char * const end;
        extern const char * const nrm;
        extern const char * const red;
        extern const char * const grn;
        extern const char * const yel;
        extern const char * const blu;
        extern const char * const mag;
        extern const char * const cyn;
        extern const char * const wht;
 
        class _logger final {
            private:
                _logger() = default;
                _logger( _logger &other ) = delete;
                void operator=( const _logger & ) = delete;
                const char *s_str[ 7 ] = { "", "[fatal]: ", "[error]: ", "[warning]: ", "[info]: ", "[debug] ", "" }; // skipcq: CXX-W2066
                uint8_t base = { 10U };
                size_t n{ 0U };
                uint8_t precision { 6U };
                #if ( Q_TRACE_BUFSIZE < 36 )
                    #define Q_TRACE_BUFSIZE     ( 36 )
                #endif
                char buffer[ Q_TRACE_BUFSIZE ] = { 0 }; // skipcq: CXX-W2066
                char preFix[ 5 ] = { 0 }; // skipcq: CXX-W2066
                util::putChar_t writeChar{ nullptr };
                void writeNumStr( void ) noexcept;
            public:
                static _logger& getInstance( void ) noexcept;
                template <typename T>
                inline _logger& _log_integer( const T& v, bool is_int )
                {
                    /*cstat -MISRAC++2008-5-0-9 -MISRAC++2008-5-0-8*/
                    if ( is_int ) {
                        (void)util::integerToString( static_cast<signed_t>( v ), buffer, base ); // skipcq: CXX-C1000
                    }
                    else {
                        (void)util::unsignedToString( static_cast<unsigned_t>( v ), buffer, base ); // skipcq: CXX-C1000
                    }
                    /*cstat +MISRAC++2008-5-0-9 +MISRAC++2008-5-0-8*/
                    writeNumStr();
                    return *this;
                }
                _logger& operator<<( const char& v );
                _logger& operator<<( const char * s );
                _logger& operator<<( const short& v );
                _logger& operator<<( const int& v );
                _logger& operator<<( const long int& v );
                _logger& operator<<( const unsigned char& v );
                _logger& operator<<( const unsigned short& v );
                _logger& operator<<( const unsigned int& v );
                _logger& operator<<( const unsigned long& v );
                _logger& operator<<( const void * const p );
                _logger& operator<<( const float64_t& v );
                _logger& operator<<( const lout_base& f );
                _logger& operator<<( const mem& m );
                _logger& operator<<( const pre& m );
                _logger& operator<<( const task& t );
                _logger& operator<<( const qOS::timer& t );
                _logger& operator<<( const qOS::stateMachine& sm );
                _logger& operator<<( const qOS::sm::state& s );
                _logger& operator<<( const qOS::trigger& t );
                _logger& operator<<( const qOS::input::channel& in );
                _logger& operator<<( const qOS::string & s );
 
            friend _logger& out( const logSeverity s, const source_location &loc ) noexcept;
            friend void setOutputFcn( util::putChar_t fcn );
        };
        extern _logger& _logger_out; // skipcq: CXX-W2011, CXX-W2009
        void setOutputFcn( util::putChar_t fcn );
 
        _logger& out( const logSeverity s = logSeverity::none, const source_location &loc = source_location::current() ) noexcept;
        /* cppcheck-suppress functionStatic */
        inline const char * var( const char * vname ){ return vname; }
    }
}
 
#define var(v)  var( #v ) << '=' << (v)
#endif /*QOS_CPP_LOGGER*/