co/base/log.h

Go to the documentation of this file.

/* Copyright (c) 2005-2011, Stefan Eilemann <eile@equalizergraphics.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 COBASE_LOG_H
#define COBASE_LOG_H

#include <co/base/api.h>

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

namespace co
{
namespace base
{
    class Clock;

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

    enum LogTopic
    {
        LOG_PLUGIN = 0x1,        
        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; } // use counted variable to allow
        void enableFlush()                  //   nested enable/disable calls
            { 
                assert( _blocked );// Too many enableFlush on log stream
                --_blocked;
            }

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

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

        void setLogInfo( const char* file, const int line )
            { _file = file; _line = line; }

    protected:
        virtual int_type overflow( LogBuffer::int_type c );
        
        virtual int sync() 
            {
                if( !_blocked )
                {
                    const std::string& string = _stringStream.str();
                    _stream.write( string.c_str(), string.length( ));
                    _stream.rdbuf()->pubsync();
                    _stringStream.str( "" );
                }
                _newLine = true;
                return 0;
            }

    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;
    };

    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 COBASE_API int level;

        static COBASE_API unsigned topics;

        static COBASE_API Log& instance();

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

        static COBASE_API void exit();

        static std::string& getLogLevelString();

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

        static COBASE_API std::ostream& getOutput ();

        static COBASE_API void setClock( Clock* clock );

        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 ); }
    };

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

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

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

#define EQERROR (co::base::Log::level >= co::base::LOG_ERROR) &&    \
    co::base::Log::instance( __FILE__, __LINE__ )

#define EQWARN  (co::base::Log::level >= co::base::LOG_WARN)  &&    \
    co::base::Log::instance( __FILE__, __LINE__ )

#define EQINFO  (co::base::Log::level >= co::base::LOG_INFO)  &&    \
    co::base::Log::instance( __FILE__, __LINE__ )

#ifdef NDEBUG
#  define EQVERB if( false )                                    \
        co::base::Log::instance( __FILE__, __LINE__ )
#else

#  define EQVERB (co::base::Log::level >= co::base::LOG_VERB)  &&    \
    co::base::Log::instance( __FILE__, __LINE__ )
#endif

#define EQLOG(topic)  (co::base::Log::topics & (topic))  &&  \
    co::base::Log::instance( __FILE__, __LINE__ )

#endif //COBASE_LOG_H