log.h

Go to the documentation of this file.

/* Copyright (c) 2005-2014, 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/compiler.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  
};

namespace detail { class Log; }

class Log : public std::ostream
{
public:
    LUNCHBOX_API void indent();

    LUNCHBOX_API void exdent();

    LUNCHBOX_API void disableFlush();

    LUNCHBOX_API void enableFlush();

    LUNCHBOX_API void forceFlush();

    LUNCHBOX_API void disableHeader();

    LUNCHBOX_API void 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(); 

    LUNCHBOX_API void setThreadName( const std::string& name ); 
    LUNCHBOX_API const std::string& getThreadName() const; 

private:
    detail::Log* const impl_;

    Log();

    template< class T > friend void perThreadDelete( T* );
    virtual ~Log();

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

    void setLogInfo( const char* file, const int 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 );

inline std::ostream& startBlock( std::ostream& os )
    { return os << indent << disableFlush << disableHeader; }
inline std::ostream& stopBlock( std::ostream& os )
    { return os << enableHeader << enableFlush << exdent; }

}

#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