logStream.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_COMMON_LOGSTREAM_H
#define BALL_COMMON_LOGSTREAM_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifndef BALL_COMMON_DEBUG_H
# include <BALL/COMMON/debug.h>
#endif

#ifdef BALL_HAS_SYS_TIME_H
# include <sys/time.h>
#endif

#ifdef BALL_HAS_TIME_H
# include <time.h>
#endif

#ifdef BALL_HAS_SSTREAM
# include <sstream>
#else
# include <strstream>
#endif

#include <iostream>
#include <list>
#include <vector>
#include <string>


using std::list;
using std::vector;
using std::string;

namespace BALL 
{


  // forward declarations
  class LogStream;
  class LogStreamNotifier;

  class BALL_EXPORT LogStreamBuf
    : public std::streambuf
  {

    friend class LogStream;

    public:

    static const int MAX_LEVEL;
    static const int MIN_LEVEL;
    static const Time MAX_TIME;

    
    LogStreamBuf();

    virtual ~LogStreamBuf();
    
    

    
    virtual void dump(std::ostream& s);



    virtual int sync();

    virtual int overflow(int c = -1);

    BALL_EXPORT struct StreamStruct
    {
      std::ostream*       stream;
      string              prefix;
      int                 min_level;
      int                 max_level;
      LogStreamNotifier*  target;
    
      StreamStruct()
        : stream(0),
          min_level(MIN_LEVEL),
          max_level(MAX_LEVEL),
          target(0)
      {
      }
      
      // Delete the notification target.
      ~StreamStruct()
      {
      }
    };


    protected:

    struct LoglineStruct 
    { 
      int     level;
      string  text;
      Time  time;

      LoglineStruct()
        : level(0),
          text(""),
          time(0)
      {}
    };

    typedef struct LoglineStruct Logline;


    // interpret the prefix format string and return the expanded prefix
    string expandPrefix_(const string& prefix, int level, Time time) const;

    char*                   pbuf_;

    vector<Logline>         loglines_;
  
    int                     level_;

    int                     tmp_level_;
    
    list<StreamStruct>      stream_list_;

    string                  incomplete_line_;
  };


  class BALL_EXPORT LogStreamNotifier
  {
    public:
    
    LogStreamNotifier();
      
    virtual ~LogStreamNotifier();

    virtual void logNotify();

    void registerAt(LogStream& log_stream,
                    int min_level = LogStreamBuf::MIN_LEVEL, 
                    int max_level = LogStreamBuf::MAX_LEVEL);
    void unregister();

    protected:

    std::stringstream stream_;

    LogStream* registered_at_;
  };



  class BALL_EXPORT LogStream
    : public std::ostream
  {
    public:


      
    enum LogStreamLevel
    {
      ERROR_LEVEL = 2000 ,
      
      WARNING_LEVEL = 1000,
      INFORMATION_LEVEL = 0
    };

  

    LogStream(LogStreamBuf* buf = 0, bool delete_buf = true, bool associate_stdio = false);

    virtual ~LogStream();
  


    LogStreamBuf* rdbuf();

    LogStreamBuf* operator -> ();


    void setLevel(int level);

    int getLevel();

    LogStream& level(int level);

    LogStream& info(int n = 0);

    LogStream& error(int n = 0);

    LogStream& warn(int n = 0);



    void insert
      (std::ostream& s, int min_level = LogStreamBuf::MIN_LEVEL, 
       int max_level = LogStreamBuf::MAX_LEVEL);

    void remove(std::ostream& s);

    void insertNotification(std::ostream& s, 
                            LogStreamNotifier& target,
                            int min_level = LogStreamBuf::MIN_LEVEL, 
                            int max_level = LogStreamBuf::MAX_LEVEL);

    void setMinLevel(const std::ostream& s, int min_level);
    
    void setMaxLevel(const std::ostream& s, int max_level);

    void setPrefix(const std::ostream& s, const string& prefix);

    void disableOutput() ;

    void enableOutput() ;

    bool outputEnabled() const
      ;

    void flush()
      ;
    
      
    void clear();
  
    Size getNumberOfLines
      (int min_level = LogStreamBuf::MIN_LEVEL, 
       int max_level = LogStreamBuf::MAX_LEVEL) const;

    string getLineText(const Index& index) const;

    Time getLineTime(const Index& index) const; 
  
    int getLineLevel(const Index& index) const;
    
    list<int> filterLines
      (int min_level = LogStreamBuf::MIN_LEVEL, int max_level = LogStreamBuf::MAX_LEVEL,
       Time earliest = 0, Time latest = LogStreamBuf::MAX_TIME, 
       const string& s = "") const;

    private:

    typedef std::list<LogStreamBuf::StreamStruct>::iterator StreamIterator;
    
    StreamIterator findStream_(const std::ostream& stream);
    bool hasStream_(std::ostream& stream);
    bool bound_() const;

    // flag needed by the destructor to decide whether the streambuf
    // has to be deleted. If the default ctor is used to create
    // the LogStreamBuf, delete_buffer_ is set to true and the ctor
    // also deletes the buffer.
    bool  delete_buffer_;
    bool  disable_output_;
  };


  BALL_EXPORT extern LogStream  Log;

  
# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/COMMON/logStream.iC>
# endif

} // namespace BALL

#endif // BALL_COMMON_LOGSTREAM_H

---