DebugStream.h

// -*- C++ -*-

// Created by Lars Gullik BjЬnnes
// Copyright 1999 Lars Gullik BjЬnnes (larsbj@lyx.org)
// Released into the public domain.

// Implemented and tested on g++ 2.7.2.3

// Primarily developed for use in the LyX Project http://www.lyx.org/
// but should be adaptable to any project.

// (c) 2002 adapted for UniSet by Lav, GNU GPL license
// Modify for UniSet by pv@eterspft.ru, GNU GPL license

#ifndef DEBUGSTREAM_H
#define DEBUGSTREAM_H

//#ifdef __GNUG__
//#pragma interface
//#endif

#include <iostream>
#include <string>
#include <sigc++/sigc++.h>
#include "Debug.h"

#ifdef TEST_DEBUGSTREAM
#include <string>
struct Debug {
    enum type {
        NONE = 0,
        INFO       = (1 << 0),   // 1
        WARN       = (1 << 1),   // 2
        CRIT       = (1 << 2)   // 4
    };
    static const type ANY = type(INFO | WARN | CRIT);
    static Debug::type value(std::string const & val) {
        if (val == "NONE") return Debug::NONE;
        if (val == "INFO") return Debug::INFO;
        if (val == "WARN") return Debug::WARN;
        if (val == "CRIT") return Debug::CRIT;
        return Debug::NONE;
    }
};
#endif

class DebugStream : public std::ostream
{
public:
    explicit DebugStream(Debug::type t = Debug::NONE);

    explicit
    DebugStream(char const * f, Debug::type t = Debug::NONE, bool truncate=false );

    virtual ~DebugStream();

    typedef sigc::signal<void,const std::string&> StreamEvent_Signal;
    StreamEvent_Signal signal_stream_event();

    void level(Debug::type t) {
        dt = Debug::type(t & Debug::ANY);
    }

    Debug::type level() const {
        return dt;
    }

    void addLevel(Debug::type t) {
        dt = Debug::type(dt | t);
    }

    void delLevel(Debug::type t) {
        dt = Debug::type(dt & ~t);
    }

    virtual void logFile( const std::string& f, bool truncate=false );

    inline std::string getLogFile(){ return fname; }

    inline bool debugging(Debug::type t = Debug::ANY) const
    {  return (dt & t); }

    std::ostream & debug(Debug::type t = Debug::ANY);
//        if (dt & t) return *this;
//        return nullstream;
//    }


    std::ostream & operator[](Debug::type t) {
        return debug(t);
    }

    inline std::ostream& to_end(Debug::type t)
    { return this->operator()(t); }

    std::ostream& operator()(Debug::type t);

    inline void showDateTime(bool s)
    { show_datetime = s; }

// короткие функции (для удобства)
// log.level1()  - вывод с датой и временем  "date time [LEVEL] ...",
//    если вывод даты и времени не выключен при помощи showDateTime(false)
// if( log.is_level1() ) - проверка включён ли лог.."

#define DMANIP(FNAME,LEVEL) \
    inline std::ostream& FNAME( bool showdatetime=true ) \
    {\
        if( showdatetime )\
            return operator[](Debug::LEVEL); \
        return  operator()(Debug::LEVEL); \
    } \
\
    inline bool is_##FNAME() \
    { return debugging(Debug::LEVEL); }

    DMANIP(level1,LEVEL1)
    DMANIP(level2,LEVEL2)
    DMANIP(level3,LEVEL3)
    DMANIP(level4,LEVEL4)
    DMANIP(level5,LEVEL5)
    DMANIP(level6,LEVEL6)
    DMANIP(level7,LEVEL7)
    DMANIP(level8,LEVEL8)
    DMANIP(level9,LEVEL9)
    DMANIP(info,INFO)
    DMANIP(warn,WARN)
    DMANIP(crit,CRIT)
    DMANIP(repository,REPOSITORY)
    DMANIP(system,SYSTEM)
    DMANIP(exception,EXCEPTION)
    DMANIP(any,ANY)
#undef DMANIP

    std::ostream& printDate(Debug::type t, char brk='/');
    std::ostream& printTime(Debug::type t, char brk=':');
    std::ostream& printDateTime(Debug::type t);

    std::ostream& pos(int x, int y);

    const DebugStream &operator=(const DebugStream& r);

    inline void setLogName( const std::string& n ){ logname = n; }
    inline std::string  getLogName(){ return logname; }

protected:
    void sbuf_overflow( const std::string& s );

// private:
    Debug::type dt;
    std::ostream nullstream;
    struct debugstream_internal;
    debugstream_internal * internal;
    bool show_datetime;
    std::string fname;

    StreamEvent_Signal s_stream;
    std::string logname; 
};

#endif