einhard.hpp

Go to the documentation of this file.

 
#include <assert.h>
#include <iostream>
#include <iomanip>
#include <ctime>
#include <cstring>
#include <sstream>
#include <bitset>
 
#include "stacktrace.h"
 
// This C header is sadly required to check whether writing to a terminal or a file
#include <cstdio>
 
#include <unistd.h>  // for isatty
 
#ifdef __GNUC__
#define EINHARD_ALWAYS_INLINE_ __attribute__((always_inline))
#else
#define EINHARD_ALWAYS_INLINE_
#endif
 
// Error on MacOS:
//    “thread-local storage is unsupported for the current target”
// To enable a workaround the EINHARD_NO_THREAD_LOCAL macro must be defined.
#ifdef __APPLE__
#define EINHARD_NO_THREAD_LOCAL 1
#endif
 
namespace einhard
{
    extern char const VERSION[];
 
    enum LogLevel
    {
        ALL,   
        TRACE, 
        DEBUG, 
        INFO,  
        WARN,  
        ERROR, 
        FATAL, 
        OFF    
    };
 
    template <LogLevel> const char *getLogLevelString() noexcept;
    const char *getLogLevelString( LogLevel level );
 
    LogLevel getLogLevel( const std::string &level );
 
    template <LogLevel> const char *colorForLogLevel() noexcept;
 
    template <typename Parent> class Color
    {
    public:
        EINHARD_ALWAYS_INLINE_ Color() noexcept : reset( true )
        {
        }
        EINHARD_ALWAYS_INLINE_ Color<Parent> operator~() const noexcept
        {
            return {false};
        }
        EINHARD_ALWAYS_INLINE_ char const *ansiCode() const noexcept
        {
            return Parent::ANSI();
        }
        EINHARD_ALWAYS_INLINE_ bool resetColor() const noexcept
        {
            return reset;
        }
 
    private:
        EINHARD_ALWAYS_INLINE_ Color( bool r ) noexcept : reset( r )
        {
        }
        bool reset;
    };
#define _COLOR( name, code )                                                                                           \
    struct name##_t_                                                                                               \
    {                                                                                                              \
        static char const *ANSI() noexcept                                                                     \
        {                                                                                                      \
            return "\33[" code "m";                                                                        \
        }                                                                                                      \
    };                                                                                                             \
    typedef Color<name##_t_> name
 
    _COLOR(DGray,   "01;30");
    _COLOR(Black,   "00;30");
    _COLOR(Red,     "01;31");
    _COLOR(DRed,    "00;31");
    _COLOR(Green,   "01;32");
    _COLOR(DGreen,  "00;32");
    _COLOR(Yellow,  "01;33");
    _COLOR(Orange,  "00;33");
    _COLOR(Blue,    "01;34");
    _COLOR(DBlue,   "00;34");
    _COLOR(Magenta, "01;35");
    _COLOR(DMagenta,"00;35");
    _COLOR(Cyan,    "01;36");
    _COLOR(DCyan,   "00;36");
    _COLOR(White,   "01;37");
    _COLOR(Gray,    "00;37");
    _COLOR(NoColor, "0"    );
#undef _COLOR
 
    struct DummyOutputFormatter
    {
        template <typename T> EINHARD_ALWAYS_INLINE_ DummyOutputFormatter &operator<<( const T & ) noexcept
        {
            return *this;
        }
        EINHARD_ALWAYS_INLINE_ DummyOutputFormatter &operator<<(
            std::ostream &( * )( std::ostream & ) ) noexcept
        {
            return *this;
        }
    };
 
    class UnconditionalOutput
    {
    private:
        // Pointer to the thread_local stringstream (if enabled)
        std::ostringstream *out;
#ifdef EINHARD_NO_THREAD_LOCAL
        // without thread_local we simply use a local stringstream object
        std::ostringstream realOut;
#endif
        // The number of chars required for aligning
        unsigned char indent;
        // Whether to colorize the output
        const bool colorize;
        // Whether the color needs to be reset with the next operator<<
        bool resetColor = false;
 
    public:
        template <LogLevel VERBOSITY>
        EINHARD_ALWAYS_INLINE_ UnconditionalOutput( bool colorize_, const char *areaName,
                                std::integral_constant<LogLevel, VERBOSITY> )
            : colorize( colorize_ )
        {
            doInit<VERBOSITY>( areaName );
        }
 
        template <typename T> UnconditionalOutput &operator<<( const Color<T> &col )
        {
            if( colorize )
            {
                *out << col.ansiCode();
                resetColor = col.resetColor();
            }
            return *this;
        }
 
        EINHARD_ALWAYS_INLINE_ UnconditionalOutput &operator<<( std::ostream &( *manip )( std::ostream & ) )
        {
            *out << manip;
            return *this;
        }
 
        template <typename T> EINHARD_ALWAYS_INLINE_ UnconditionalOutput &operator<<( const T &msg )
        {
            *out << msg;
            checkColorReset();
            return *this;
        }
 
        void doCleanup(std::FILE *outfile = stdout) noexcept;
 
    protected:
        EINHARD_ALWAYS_INLINE_ UnconditionalOutput( bool colorize_ ) : colorize( colorize_ )
        {
        }
        template <LogLevel VERBOSITY> void doInit( const char *areaName );
        void checkColorReset();
    };
    class OutputFormatter : public UnconditionalOutput
    {
        private:
            // the output file (normally used to switch from stdout to stderr)
            std::FILE *const outfile;
            // Whether output is enabled
            const bool enabled;
 
        public:
            OutputFormatter( const OutputFormatter & ) = delete;
            OutputFormatter( OutputFormatter && ) = default;
 
            template <LogLevel VERBOSITY>
            EINHARD_ALWAYS_INLINE_ OutputFormatter( bool enabled_, bool const colorize_,
                                const char *areaName,
                                std::integral_constant<LogLevel, VERBOSITY>,
                                std::FILE *outfile_ = stdout )
                : UnconditionalOutput( colorize_ ), enabled( enabled_ ), outfile( outfile_ )
            {
                if( enabled )
                {
                    doInit<VERBOSITY>( areaName );
                }
            }
 
            template <typename T> OutputFormatter &operator<<( const Color<T> &col )
            {
                if( enabled )
                {
                    UnconditionalOutput::operator<<(col);
                }
                return *this;
            }
 
            EINHARD_ALWAYS_INLINE_ OutputFormatter &operator<<( std::ostream &( *manip )( std::ostream & ) )
            {
                if( enabled )
                {
                    UnconditionalOutput::operator<<(manip);
                }
                return *this;
            }
 
            template <typename T> EINHARD_ALWAYS_INLINE_ OutputFormatter &operator<<( const T &msg )
            {
                if( enabled )
                {
                    UnconditionalOutput::operator<<(msg);
                }
                return *this;
            }
 
            EINHARD_ALWAYS_INLINE_
            ~OutputFormatter( )
            {
                if( enabled )
                {
                    doCleanup( outfile );
                }
            }
    };
 
    template<LogLevel MAX = ALL> class Logger
    {
        private:
            char areaName[32 - sizeof( LogLevel ) - sizeof( bool )] = {'\0'};
            LogLevel verbosity;
            bool colorize_stdout;
            bool colorize_stderr;
 
        public:
            Logger( const LogLevel verbosity = WARN ) : verbosity( verbosity )
            {
                // use some, sadly not c++-ways to figure out whether we are writing ot a terminal
                // only colorize when we are writing ot a terminal
                colorize_stdout = isatty( fileno( stdout ) );
                colorize_stderr = isatty( fileno( stderr ) );
            };
            Logger( const LogLevel verbosity, const bool colorize )
                : verbosity( verbosity ), colorize_stdout( colorize ), colorize_stderr( colorize ) {};
 
            void setAreaName( const char *name )
            {
                assert( name );
                std::strncpy( &areaName[0], name, sizeof( areaName ) - 1 );
                areaName[sizeof( areaName ) - 1] = '\0';
            }
            EINHARD_ALWAYS_INLINE_
            void setAreaName( const std::string &name )
            {
                setAreaName(name.c_str());
            }
 
#ifdef NDEBUG
            DummyOutputFormatter trace() const noexcept
            {
                return DummyOutputFormatter();
            }
 
            template <typename... Ts> void trace( Ts &&... ) const noexcept
            {
            }
#else
            OutputFormatter trace() const
            {
                return {isEnabled<TRACE>(), colorize_stdout, areaName,
                    std::integral_constant<LogLevel, TRACE>()};
            }
 
            template <typename... Ts> void trace( Ts &&... args ) const noexcept
            {
                if( isEnabled<TRACE>() )
                {
                    UnconditionalOutput o{colorize_stdout, areaName,
                                  std::integral_constant<LogLevel, TRACE>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup();
                }
            }
#endif
#ifdef NDEBUG
            DummyOutputFormatter debug() const noexcept
            {
                return DummyOutputFormatter();
            }
            template <typename... Ts> void debug( Ts &&... ) const noexcept
            {
            }
#else
            OutputFormatter debug() const
            {
                return {isEnabled<DEBUG>(), colorize_stdout, areaName,
                    std::integral_constant<LogLevel, DEBUG>()};
            }
            template <typename... Ts> void debug( Ts &&... args ) const noexcept
            {
                if( isEnabled<DEBUG>() )
                {
                    UnconditionalOutput o{colorize_stdout, areaName,
                              std::integral_constant<LogLevel, DEBUG>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup();
                }
            }
#endif
            OutputFormatter info() const
            {
                return {isEnabled<INFO>(), colorize_stdout, areaName,
                    std::integral_constant<LogLevel, INFO>()};
            }
            template <typename... Ts> void info( Ts &&... args ) const noexcept
            {
                if( isEnabled<INFO>() )
                {
                    UnconditionalOutput o{colorize_stdout, areaName,
                              std::integral_constant<LogLevel, INFO>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup();
                }
            }
            OutputFormatter warn() const
            {
                return {isEnabled<WARN>(), colorize_stderr, areaName,
                    std::integral_constant<LogLevel, WARN>(), stderr};
            }
            template <typename... Ts> void warn( Ts &&... args ) const noexcept
            {
                if( isEnabled<WARN>() )
                {
                    UnconditionalOutput o{colorize_stderr, areaName,
                              std::integral_constant<LogLevel, WARN>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup(stderr);
                }
            }
            OutputFormatter error() const
            {
                return {isEnabled<ERROR>(), colorize_stderr, areaName,
                    std::integral_constant<LogLevel, ERROR>(), stderr};
            }
            template <typename... Ts> void error( Ts &&... args ) const noexcept
            {
                if( isEnabled<ERROR>() )
                {
                    UnconditionalOutput o{colorize_stderr, areaName,
                              std::integral_constant<LogLevel, ERROR>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup(stderr);
                }
            }
            OutputFormatter fatal() const
            {
                return {isEnabled<FATAL>(), colorize_stderr, areaName,
                    std::integral_constant<LogLevel, FATAL>(), stderr};
            }
            template <typename... Ts> void fatal( Ts &&... args ) const noexcept
            {
                if( isEnabled<FATAL>() )
                {
                    UnconditionalOutput o{colorize_stderr, areaName,
                              std::integral_constant<LogLevel, FATAL>()};
                    auto &&unused = {&( o << args )...};
                    o.doCleanup(stderr);
                    print_stacktrace(stderr, 63, 2);
                }
            }
 
            template <LogLevel LEVEL> bool isEnabled() const noexcept
            {
#ifdef NDEBUG
                if( LEVEL == DEBUG || LEVEL == TRACE ) {
                    return false;
                }
#endif
                return ( MAX <= LEVEL && verbosity <= LEVEL );
            }
 
            inline void setVerbosity( LogLevel verbosity ) noexcept
            {
                this->verbosity = verbosity;
            }
            inline LogLevel getVerbosity() const noexcept
            {
                return this->verbosity;
            }
            inline char const * getVerbosityString( ) const
            {
                return getLogLevelString(verbosity);
            }
            void setColorize( bool colorize ) noexcept
            {
                this->colorize_stdout = colorize;
                this->colorize_stderr = colorize;
            }
            bool getColorize() const noexcept
            {
                return this->colorize_stdout || this->colorize_stderr;
            }
    };
}
 
// vim: ts=4 sw=4 tw=100 noet