log.h

Go to the documentation of this file.

/* Copyright (c) 2005-2013, Stefan Eilemann <eile@equalizergraphics.com>
 *                    2011, Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef LUNCHBOX_LOG_H
#define LUNCHBOX_LOG_H

#include <lunchbox/api.h>
#include <lunchbox/types.h>

#include <assert.h>
#include <iomanip>
#include <iostream>
#include <sstream>

namespace lunchbox
{
    enum LogLevel
    {
        LOG_ERROR = 1, 
        LOG_WARN,      
        LOG_INFO,      
        LOG_VERB,      
        LOG_ALL
    };

    enum LogTopic
    {
        LOG_EXCEPTION = 0x01,    
        LOG_PLUGIN    = 0x02,    
        LOG_CUSTOM    = 0x10,    
        LOG_ANY       = 0xffffu  
    };

    class LogBuffer : public std::streambuf
    {
    public:
        LogBuffer( std::ostream& stream )
                : _line(0), _indent(0), _blocked(0), _noHeader(0),
                  _newLine(true), _stream(stream)
            { _thread[0] = 0; }
        virtual ~LogBuffer() {}

        void indent() { ++_indent; }
        void exdent() { --_indent; }

        void disableFlush() { ++_blocked; assert( _blocked < 100 ); }
        void enableFlush()
            {
                assert( _blocked );// Too many enableFlush on log stream
                --_blocked;
            }

        void disableHeader() { ++_noHeader; } // use counted variable to allow
        void enableHeader()  { --_noHeader; } //   nested enable/disable calls

        LUNCHBOX_API void setThreadName( const std::string& name );
        const char* getThreadName() const { return _thread; }

        LUNCHBOX_API void setLogInfo( const char* file, const int line );

    protected:
        virtual int_type overflow( LogBuffer::int_type c );

        virtual int sync();

    private:
        LogBuffer( const LogBuffer& );
        LogBuffer& operator = ( const LogBuffer& );

        char _thread[12];

        std::string _file;

        int _line;

        int _indent;

        int _blocked;

        int _noHeader;

        bool _newLine;

        std::ostringstream _stringStream;

        std::ostream& _stream;

        static Lock _lock;
    };

    class Log : public std::ostream
    {
    public:

        Log() : std::ostream( &_logBuffer ), _logBuffer( getOutput( )){}
        virtual ~Log() { _logBuffer.pubsync(); }

        void indent() { _logBuffer.indent(); }
        void exdent() { _logBuffer.exdent(); }
        void disableFlush() { _logBuffer.disableFlush(); }
        void enableFlush()  { _logBuffer.enableFlush();  }
        void forceFlush()  { _logBuffer.pubsync();  }
        void disableHeader() { _logBuffer.disableHeader(); }
        void enableHeader()  { _logBuffer.enableHeader();  }

        static LUNCHBOX_API int level;

        static LUNCHBOX_API unsigned topics;

        static LUNCHBOX_API Log& instance();

        static LUNCHBOX_API Log& instance( const char* file, const int line );

        static LUNCHBOX_API void exit();

        static LUNCHBOX_API void reset();

        static std::string& getLogLevelString();

        static LUNCHBOX_API int getLogLevel( const char* level );

        static LUNCHBOX_API void setOutput( std::ostream& stream );

        static LUNCHBOX_API bool setOutput( const std::string& file );

        static LUNCHBOX_API std::ostream& getOutput ();

        static LUNCHBOX_API void setClock( Clock* clock );

        static const Clock& getClock(); 

        void setThreadName( const std::string& name )
            { _logBuffer.setThreadName( name ); }

        const char* getThreadName() const { return _logBuffer.getThreadName(); }

    private:
        LogBuffer _logBuffer;

        Log( const Log& );
        Log& operator = ( const Log& );

        void setLogInfo( const char* file, const int line )
            { _logBuffer.setLogInfo( file, line ); }
    };

    LUNCHBOX_API std::ostream& indent( std::ostream& os );
    LUNCHBOX_API std::ostream& exdent( std::ostream& os );

    LUNCHBOX_API std::ostream& disableFlush( std::ostream& os );
    LUNCHBOX_API std::ostream& enableFlush( std::ostream& os );
    LUNCHBOX_API std::ostream& forceFlush( std::ostream& os );

    LUNCHBOX_API std::ostream& disableHeader( std::ostream& os );
    LUNCHBOX_API std::ostream& enableHeader( std::ostream& os );
}

#define LBERROR (lunchbox::Log::level >= lunchbox::LOG_ERROR) &&    \
    lunchbox::Log::instance( __FILE__, __LINE__ )

#define LBWARN  (lunchbox::Log::level >= lunchbox::LOG_WARN)  &&    \
    lunchbox::Log::instance( __FILE__, __LINE__ )

#define LBINFO  (lunchbox::Log::level >= lunchbox::LOG_INFO)  &&    \
    lunchbox::Log::instance( __FILE__, __LINE__ )

#ifdef NDEBUG
#  define LBVERB if( false )                                    \
        lunchbox::Log::instance( __FILE__, __LINE__ )
#else

#  define LBVERB (lunchbox::Log::level >= lunchbox::LOG_VERB)  &&    \
    lunchbox::Log::instance( __FILE__, __LINE__ )
#endif

#define LBLOG(topic)  (lunchbox::Log::topics & (topic))  &&  \
    lunchbox::Log::instance( __FILE__, __LINE__ )

#define LBTHROW(exc)                                                \
    {                                                               \
        LBLOG(lunchbox::LOG_EXCEPTION) << exc.what() << std::endl;  \
        throw exc;                                                  \
    }

#endif //LUNCHBOX_LOG_H