Log.h

// Log.h -- Interface to a level/pattern based logging mechanism.

/*
 * Copyright (C) 2003 Tudor Hulubei <tudor@hulubei.net>.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2, or (at
 * your option) any later version.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA,
 * 02111-1307, USA.
 */

// $Id: Log_8h-source.html,v 1.1 2005/05/25 12:37:18 tudor Exp $

#ifndef _CSP_KERNEL_Log_H
#define _CSP_KERNEL_Log_H


#include <vector>
#include <fstream>


CSP_NAMESPACE_BEGIN(csp);


enum LogLevel
{
    Info = 0, // Informational messages, versions, copyrights, etc.
    Error,    // Errors in the code's logic.
    Warning,  // Warnings about unusual conditions.
    Notice,   // Useful notices.
    Debug0,   // Debugging messages (level 0, relatively quiet).
    Debug1,   // Debugging messages (level 1, a bit more verbose).
    Debug2,   // Debugging messages (level 2, verbose).
    Debug,    // Debugging messages (everything).
    MaxLevel
};

// Logging preamble flags.
enum LogPreambleFlags
{
    LogProgram = 1,
    LogProcessId = 2,
    LogThreadId = 4,
    LogDate = 8,
    LogTime = 16,
    LogLevelName = 32,
    LogCategory = 64,
    LogIndentationLevel = 128,
    LogAll = 0xFFFFFFFF
};


class CSP_API GlobalLog
{
  public:
    typedef unsigned int PreambleFlags;

    GlobalLog(
        const wstring& programName,
        Mutex::GlobalData& globalData,
        size_t maxLineLength);

    ~GlobalLog() { while (m_mutex.iHoldIt()) m_mutex.release();  }

    void registerPattern(const wstring& pattern);

    void unregisterPattern(const wstring& pattern);

    void clearPatterns()
    {
        m_patterns.clear();
        registerPattern(L"csp::Log");
    }

    const vector<wstring>& patterns() const { return m_patterns; }

    LogLevel level() const { return m_level; }

    void setLevel(const LogLevel level);

    LogLevel threshold() const { return m_threshold; }

    void setThreshold(const LogLevel threshold);

    void setPreambleFlags(const PreambleFlags preambleFlags) {
        m_preambleFlags = preambleFlags; }

    void lock() { m_mutex.acquire(); }

    void unlock() { m_mutex.release(); }

    bool isEnabled(const LogLevel level) {
        // Test first the condition most likely to fail.
        return level <= m_level && level >= 0; }

    bool isEnabled(const wstring& category);

    const wstring levelName(const LogLevel level) const;

    const wstring levelColor(const LogLevel level) const;

    void write(
        const wstring& category,
        const LogLevel level,
        wostringstream& wos);

    void setIndentationState(const bool useIndentation)
    {
        m_useIndentation = useIndentation;
    }

    void setIndentationAmount(const size_t spaces);

    void registerIndentationLevelPlaceholder(int& indentationLevel);

    void unregisterIndentationLevelPlaceholder();

    const int& indentationLevelPlaceholder() const;

    bool outputToTTY() const
    {
#ifdef _WIN32
        return false;
#else
        return isatty(2);
#endif
    }

  protected:
    const wstring preamble(
        const wstring& category,
        const LogLevel level);

    void splitLine(
        const wstring& line,
        vector<wstring>& lines,
        wstring::size_type reserved);

    void splitMultiLine(const wstring& line, vector<wstring>& lines);

    const wstring indent(const int threadId) const;

    const int indentationLevel(const int threadId) const;

    const wstring fit(const wstring& text, const size_t limit);

    wstring m_programName;

    LogLevel m_level;

    LogLevel m_threshold;

    vector<wstring> m_patterns;

    vector<pair<wstring, wstring> > m_levelInfo;

    PreambleFlags m_preambleFlags;

    size_t m_maxLineLength;

    bool m_useIndentation;

    size_t m_spaces;

    size_t m_maxLogLevelNameLength;

    hash_map<int, int*> m_indentationLevels;

    bool m_useColors;

    Mutex::GlobalData& m_globalData;

    Mutex m_mutex;
};


extern CSP_API GlobalLog* g_log;


class CSP_API Log
{
  public:
    Log(const wstring& programName);
    ~Log();

    static void registerPattern(const wstring& pattern) {
        g_log->registerPattern(pattern); }
    static void unregisterPattern(const wstring& pattern) {
        g_log->unregisterPattern(pattern); }
    static void clearPatterns() {
        g_log->clearPatterns(); }
    static const vector<wstring>& patterns() {
        return g_log->patterns(); }
    static LogLevel level() {
        return g_log->level(); }
    static void setLevel(LogLevel level) {
        g_log->setLevel(level); }
    static LogLevel threshold() {
        return g_log->threshold(); }
    static void setThreshold(LogLevel threshold) {
        g_log->setThreshold(threshold); }
    static void setPreambleFlags(const GlobalLog::PreambleFlags flags) {
        g_log->setPreambleFlags(flags); }
    static bool isEnabled(const LogLevel level) {
        return g_log->isEnabled(level); }
    static bool isEnabled(const wstring& category) {
        return g_log->isEnabled(category); }
    static const wstring levelName(const LogLevel level) {
        return g_log->levelName(level); }
    static const wstring levelColor(const LogLevel level) {
        return g_log->levelColor(level); }
    static void write(
        const wstring& category,
        const LogLevel level,
        wostringstream& wos) {
        return g_log->write(category, level, wos); }
    static void setIndentationState(const bool indentation) {
        g_log->setIndentationState(indentation); }
    static void setIndentationAmount(const size_t spaces) {
        g_log->setIndentationAmount(spaces); }
    static void registerIndentationLevelPlaceholder(int& indentationLevel) {
        g_log->registerIndentationLevelPlaceholder(indentationLevel); }
    static void unregisterIndentationLevelPlaceholder() {
        g_log->unregisterIndentationLevelPlaceholder(); }
    static bool outputToTTY() {
        return g_log->outputToTTY(); }

};


// This macro is used even when optimizations are turned on.  We want
// to avoid acquiring/releasing the lock for high logging levels, and
// by checking the log level _outside_ of the critical region we're
// trading a bit of correctness for a significant speed improvement
// The worst thing that can happen is that we may end up logging when
// not allowed or failing to log a few messages, if the logging level
// is changed dynamically in a different thread.  Checking the logging
// category is much slower and, more importantly, involves checking
// data (m_patterns) whose structure can be changed in another thread,
// making it unsafe to check outside the critical region.
// `isEnabled(level)' checks the "level <= m_level" condition first,
// making it very likely that in optimization mode, the overhead of
// the LOG() macro is a simple integer comparison (well, if you're
// willing to ignore the increased register pressure caused by
// populating the code with these relatively large macros).
#define LOG(category, level, message)\
{\
    using namespace csp;\
    assert(g_log);\
    if (g_log->isEnabled(level))\
    {\
        g_log->lock();\
        if (((level) <= g_log->threshold()) || g_log->isEnabled(category))\
        {\
            std::wostringstream wos;\
            wos << message;\
            g_log->write((category), (level), wos);\
        }\
        g_log->unlock();\
    }\
}


CSP_NAMESPACE_END(csp);


#endif // _CSP_KERNEL_Log_H

// Local Variables:
// mode: C++
// End:

---