---

log.hh

Go to the documentation of this file.

/* 
* log.hh - include file for qmmslog package
*
* Copyright (C) 2002 Max M. Strumia.  All rights reserved.
*
* This software is published under the terms of the Q Public License (QPL),
* the Apache Public License, and the GNU General Public License (GPL).
* copies of which have been included with this distribution.
*
*/

#ifndef _QMMS_LOG_HH
#define _QMMS_LOG_HH

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <typeinfo>
#include <syslog.h>

#include <qmutex.h>
#include <qmap.h>
#include <qstring.h>
#include <qdict.h>
#include <qptrlist.h>
#include <qdatetime.h>
#include <qregexp.h>
#include <qstringlist.h>
#include <qfile.h>
#include <qdir.h>
#include <qfileinfo.h>
#include <qtextedit.h>

using namespace std;

namespace Qmms {
namespace Log {

// forward declarations
class LogLog;
class BaseCategory;
class AppenderSkeleton;
class Hierarchy;
class Category;

typedef QMap< QString, int > StrIntMap;

typedef QMap< int, QString > IntStrMap;

typedef QDict< BaseCategory > BaseDict;

typedef QDict< AppenderSkeleton > AppDict;

typedef QMap< QString, QStringList > StrListMap;


class LogLog
   {
   private:
      LogLog();           
           
      static QString DEBUG_KEY;
            
      static QString PREFIX;
      
      static QString ERR_PREFIX;
      
      static QString WARN_PREFIX;
           
   protected:
      static bool debugEnabled;

      static bool quietMode;
        
   public:           
      virtual ~LogLog();
      
      static void init( bool enabled, bool quiet );
      
      static void setInternalDebugging( bool enabled );
      
      static bool isEnabled();
      
      static bool isQuiet();
      
      static void setQuietMode( bool mode );
      
      static void debug( QString msg );
      
      static void warn( QString msg );
      
      static void error( QString msg ); 
      
      virtual void dummy() const = 0;           
   };



class LogLevel
   {
   private:
      static StrIntMap level;
      
      static IntStrMap revLevel;

      LogLevel();      

      static void init();
   
   public:
      
      friend class Hierarchy;      
      
      static void addLevel( QString key, const int val );
      
      static void showLevels();

      static bool isGreaterOrEqual( const QString p, const QString q );
      
      static bool isLevel( const QString key );
      
      static int getValue( const QString key );
      
      static QString getKey( const int value );
            
      virtual ~LogLevel();
      
      virtual void dummy() const = 0;   
   };

class LoggingEvent
   {
   private:
      Category* category;
      
      QString level;
      
      QString message;
      
      QString fqnOfCategoryClass;
      
      QString categoryName;
      
      QDateTime timeStamp;
         
   public:
      LoggingEvent();
      
      LoggingEvent( const QString fqn, Category* cat, 
                    const QString lvl, const QString msg );
      
      ~LoggingEvent();
      
      QString getMessage() const;
      
      QString getFQN() const;
      
      Category* getCategory() const;
      
      QString getCategoryName() const;
      
      QString getLevel() const;
      
      QDateTime getTimestamp() const;
   };

class Layout
   {
   public:
      virtual QString formatEvent( const LoggingEvent* evnt ) = 0;
      
      virtual ~Layout() {};
   };

class PatternLayout : public Layout
   {
   private:
      
      QString pattern;
      
      const static QString DEFAULT_PATTERN;
      
      const static QString DEFAULT_DATETIME_FORMAT;

      QString dtFormat;
   
      bool isValidPattern( const QString ptn );
   
   public:
      PatternLayout();
      
      PatternLayout( const QString& ptn );
      
      ~PatternLayout();
      
      QString formatEvent( const LoggingEvent* evnt );
      
      bool changePattern( const QString ptn );
      
      QString getPattern() const;
      
      QString getDate( const LoggingEvent* evnt ) const;
      
      bool changeDateTimeFormat( const QString format );
   };

class SimpleLayout : public Layout
   {
   private:
      const static QString DEFAULT_DATETIME_FORMAT;
      const static QString OPEN_PAREN;
      const static QString CLOSE_PAREN;
      const static QString HYPHEN;
      const static QString COLON_SPACE;      
   
   public:
      SimpleLayout();
      
      ~SimpleLayout();
   
      QString formatEvent( const LoggingEvent* evnt ); 
   };

class HTMLLayout : public Layout
   {
   
   };
   
class Appender
   {      
   public:
      Appender();
      
      virtual ~Appender();
      
      virtual void close() = 0;
      
      virtual void doAppend( LoggingEvent* evnt) = 0;
      
      virtual QString getName() const = 0;
      
      virtual void setName( const QString& name ) = 0;

   };

class AppenderSkeleton : public Appender
   {         
   protected:      
      QString name;
      
      QString threshold;
   
   public:      
      AppenderSkeleton();
      
      AppenderSkeleton( const QString& name );
     
      virtual ~AppenderSkeleton();
      
      virtual void append( LoggingEvent* evnt ) = 0;
      
      virtual bool checkEntryConditions() const = 0;

      void doAppend( LoggingEvent* evnt );      
            
      void setName( const QString& name );
      
      QString getName() const;
      
      void setThreshold( const QString& thold );
      
      QString getThreshold() const;
      
      bool isAsSevereAsThreshold( const QString lvl ) const;      

      virtual bool requiresLayout() const = 0;
   };

class LayoutAppender : public AppenderSkeleton
   {
   protected:
      Layout* layout;
      
   public:
      LayoutAppender();
      
      LayoutAppender( const QString& name );
      
      LayoutAppender( const QString& name, Layout* lyt );
      
      virtual ~LayoutAppender();
      
      void setLayout( Layout* lyt );
      
      Layout* getLayout();

      bool requiresLayout() const; 
      
      virtual bool checkEntryConditions() const;
      
      virtual void append( LoggingEvent* evnt );
      
      virtual void subAppend( LoggingEvent* evnt ) = 0;
   };

class TextEditAppender : public LayoutAppender, public QTextEdit
   {
   public:
      TextEditAppender();
      
      TextEditAppender( QWidget* parent = 0, const QString& name = 0 );
      
      virtual ~TextEditAppender();
            
      virtual void subAppend( LoggingEvent* evnt );
           
      void close();   
   };

class StreamAppender : public LayoutAppender
   {
   protected:
      bool immediateFlush;
      
      QFile out;

   public:
      StreamAppender();
      
      StreamAppender( const QString& name );
      
      StreamAppender( const QString& name, Layout* lyt );
      
      virtual ~StreamAppender();
            
      virtual void subAppend( LoggingEvent* evnt );
      
      virtual bool checkEntryConditions() const;
      
      virtual void open( QString& name ) = 0;
      
      virtual void close();
      
      bool requiresLayout() const;
      
      bool getImmediateFlush() const;
      
      void setImmediateFlush( const bool flush );  
   };

class ConsoleAppender : public StreamAppender
   {      
   protected:
      QString target;

      const static QString STDOUT;
      
      const static QString STDERR;

   public:
      ConsoleAppender();

      ConsoleAppender( const QString& name );

      ConsoleAppender( const QString& name, Layout* lyt );

      ConsoleAppender( const QString& name, Layout* lyt, const QString& tget ); 

      ~ConsoleAppender();

      void setTarget( const QString& tget );

      QString getTarget() const;
      
      void open( QString& name );
   };

class FileAppender : public StreamAppender
   {
   protected:
      QString fileName;
      
      QDir directory;
      
   public:
      FileAppender();
      
      FileAppender( const QString& name );
      
      FileAppender( const QString& name, Layout* lyt, QString fname );
      
      ~FileAppender();
      
      virtual QString getFilename() const;
      
      virtual void open( QString& name );
      
      void setFile( QString fname );
      
      uint getFileSize() const;
      
      virtual void subAppend( LoggingEvent* evnt );
      
      void setDirectory( QString dir );
      
      QDir getDirectory() const;
   };

class RollingFileAppender : public FileAppender
   {   
   protected:
      
      const static uint DEFAULT_MAXFILESIZE;

      const static int DEFAULT_MAXBACKUP_INDEX;

      uint maxFileSize;

      int maxBackupIndex;
      
      void rollOver();
   
   public:
      RollingFileAppender();

      RollingFileAppender( const QString& name );

      RollingFileAppender( const QString& name,
                           Layout* lyt, 
                           QString filename, 
                           const bool append );

      ~RollingFileAppender();

      int getMaxBackupIndex() const;

      void setMaxBackupIndex( const int maxbackups );

      uint getMaxFileSize() const;

      void setMaxFileSize( uint maxfilesize );

      void subAppend( LoggingEvent* evnt );      
   };

class SMTPAppender : public AppenderSkeleton
   {
   public:

      SMTPAppender();

      ~SMTPAppender();
      
      bool requiresLayout() const;

      void append( LoggingEvent* evnt );

      bool checkEntryConditions() const;

      void subAppend( LoggingEvent* evnt );
   
   };

class SocketAppender : public AppenderSkeleton
   {
   
   
   };

class SyslogAppender : public LayoutAppender
   {
   protected:
      
      const static int loglevels[8];
      
      QString syslogName;

      int facility;

      Layout* layout;
      
      virtual void open();
      
      virtual void close();
      
      virtual bool reopen();
   
   public:
      SyslogAppender();
      
      SyslogAppender( const QString& name, int fac = LOG_USER );
      
      SyslogAppender( const QString& name, const QString& syslogName,
                      int fac = LOG_USER );

      virtual ~SyslogAppender();

      void setSyslogName( const QString& str );
      
      QString getSyslogName() const;
      
      int getFacility() const;
                
      void subAppend( LoggingEvent* evnt );
      
      static int toSyslogLevel( QString p );   
   };

class BaseCategory
   {
   public:
      BaseCategory();
      
      BaseCategory( const QString name );
      
      virtual bool isCategory() = 0;      

      virtual ~BaseCategory();

      QString getName() const;            
      
   protected:
      QString name;
   
      
   };

class Category : public BaseCategory
   {    
   private:
      
   protected:      
      Category();

      Category( const QString name, const QString fqn );    
      
      Category( const Category& rhs );
           
      Category* parent;
      
      QString FQN;
      
      static Hierarchy* defaultHierarchy;
      
      QString level;
      
      AppDict appenderList;
           
      bool additive;
      
      bool hasLevel;

      QString getLevel() const;
      
   public:      
      ~Category();

      friend class Hierarchy;    
      
      static Category* getInstance( const QString name, const QString fqn );

      static Category* getInstance( const QString name );

      static Hierarchy* getDefaultHierarchy();

      static Category* getRootCat();

      static void shutdown();

      bool isCategory();      

      Category* getParent() const;
      
      void setParent( Category* p );

      QString getFQN() const;

      void setFQN( const QString fqn );

      bool getAdditivity() const;

      void setAdditivity( const bool atv );
      
      void setLevel( const QString lvl );

      QString getChainedLevel();

      bool isEnabledFor( const QString lvl );
      
      void addAppender( const AppenderSkeleton* apdr );

      AppenderSkeleton* getAppender( const QString name ) const;

      bool removeAppender( AppenderSkeleton* apdr );

      bool removeAppender( QString name );

      bool contains( const AppenderSkeleton* apdr ) const;
      
      bool contains( const QString& name ) const;
      
      void callAppenders( LoggingEvent* evnt );

      void closeAllAppenders();
      
      void removeAllAppenders();

      AppDict* getAppenderList();
      
      void logWithLevel( QString lvl, QString msg );

      void debug( QString msg );
      
      void info ( QString msg );
      
      void notice( QString msg );

      void warn ( QString msg );

      void error( QString msg );

      void fatal( QString msg ); 
   };

class RootCategory : public Category 
   {
   private:
      const static QString ROOTNAME;

      const static QString DEFAULT_LEVEL;
      
      static RootCategory* theInstance;
      
      RootCategory();
   
   public:      
      static RootCategory* instance();
      
      QString getRootName() const;
      
      ~RootCategory();
   };

class ProvisionNode : public BaseCategory
   {
   private:
      ProvisionNode();
      
      ProvisionNode( const QString name, const Category* cat );

   public:
      friend class Hierarchy;

      QPtrList< Category > catList;
      
      ~ProvisionNode();

      void addElement( const Category* cat );
      
      Category* elementAt( const uint index );

      int getSize() const;

      bool isCategory();
   };

class Hierarchy 
   {
   private:      
      static Hierarchy* theInstance;
      
      static RootCategory* rootCat;
      
      static BaseDict hierDict;
      
      static const uint DICTSIZE;
      
      //QMutex* mutex;
       
      Hierarchy();
      
      Hierarchy( RootCategory* r );
           
      void updateParents( Category* cat );

      void updateChildren( ProvisionNode* pn, Category* cat );
      
   public:
      static RootCategory* getRootCat();
      
      static Hierarchy* instance();
      
      Category* getCatInstance( const QString name, const QString fqn );
      
      void shutdown();

      void testMe();
   
      QString getRootName() const;
      
      ~Hierarchy();
   };

class LogException
   {
   public:
      QString str_error;
      
      QString str_detail;
      
      LogException();

      LogException( const QString e, const QString d );
      
      QString getError();

      QString getDetail(); 
   };

class BasicConfigurator
   {
   protected:
      BasicConfigurator();
            
   public:
      ~BasicConfigurator();

      static void configure();

      static void qmmsLogOutput( QtMsgType type, const char* msg );
   };

class PropertyConfigurator : public BasicConfigurator
   {
   private:
      const static QString CATEGORY_PREFIX;

      const static QString ROOTCATEGORY_PREFIX;
      
      const static QString APPENDER_PREFIX;

      const static QString LEVEL_PREFIX;

      const static QString DEFAULT_PROPERTIES;
      
      const static QString DEBUG_PREFIX;
   
   protected:
      static AppDict apdrDict;

      static StrListMap propMap;
      
      static void parseFile( const QString filename );

      static void addLevels();

      static void parseAppenders();

      static bool verifyAppenderExists( QString name );

      static void configureRoot();

      static void parseCategories();
      
      static void configureInternalLogging();
   
   public:
      PropertyConfigurator();

      ~PropertyConfigurator();
      
      static void configure();

      static void configure( const QString filename );

      static void configureWQt();

      static void configureWQt( const QString filename );
      
      static void summarize();
   };

} // close Log namespace
} // close Qmms namespace

#endif

---