log.h

Go to the documentation of this file.

/* Copyright (c) 2005-2017, Stefan Eilemann <eile@equalizergraphics.com>
 *                          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_ERROR, 
    LOG_INFO,             
    LOG_DEBUG,            
    LOG_VERB,             
    LOG_ALL = 6
};

enum LogTopic
{
    LOG_EXCEPTION = 0x01, 
    LOG_BUG = 0x04,       
    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 LBERROR

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

#define LBDEBUG                                      \
    (lunchbox::Log::level >= lunchbox::LOG_DEBUG) && \
        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)                        \
    {                                       \
        LBDEBUG << exc.what() << std::endl; \
        throw exc;                          \
    }

#endif // LUNCHBOX_LOG_H