ADFLogMessage.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef ADF_LogMessage
#define ADF_LogMessage
#define ADF_LOGMESSAGE_H _LogMessage

#include <iostream>
#include <sstream>

namespace ADF {

class LogCollector;


class LogMessage
{   
        friend LogMessage &info(LogMessage &);
        friend LogMessage &warning(LogMessage &);    
        friend LogMessage &error(LogMessage &);
        friend LogMessage &debug(LogMessage &);
        friend LogMessage &dolog(LogMessage &); 
        friend LogMessage &clear(LogMessage &); 
        friend LogMessage &endl(LogMessage &); 
        friend LogMessage &nline(LogMessage &); 
                        
        friend LogMessage &sep(LogMessage &); 

public:
        enum ELevel { kError, kWarning, kInfo, kOut } ; 
        
private:
        static short gDebug; 
        
private:        
        static short gkMaxDepth;
        static short gkAutoClear;
        
private:
        std::string fProcessName;
        std::string fProcessMethod;
        std::string fProcessMethodTicket;
        
        unsigned int fProcessID;
        void *fProcessPtr;

private:
        short fDebug;
        
private:
        unsigned int fTicketNumber;
        ELevel fLevel;
        ELevel fLowestLevel;
        unsigned short fVerbosity;
        
private:
        unsigned short fIndentation;
        unsigned short fRealIndentation;
        bool  fIsANewLine;

private:
        std::ostringstream fHeader;
        std::ostringstream fCoreMsg;
        std::ostringstream fFooter;
        
protected:
        void NewTicket();
        
protected:
        virtual void Indent();
        virtual void Indent(std::ostream &);
        virtual void DoClear(); 
        
public:   
        LogMessage(const char *pname, unsigned int pid = 0u);
        virtual ~LogMessage();
        
        static void SetLogParameters(short global_debug_level = 0, short max_indent = 5, short max_before_clear = 7);
        static void SetDebug(short global_debug_level = 0);
        
        bool IsDebug(short debug_to_test) const
                { return debug_to_test <= gDebug; }
        

        virtual std::ostringstream &operator() () 
                { return fCoreMsg; }
        
        virtual unsigned int GetPID() const 
                { return fProcessID; }
        virtual void SetPID(unsigned int pid) 
                { fProcessID = pid; }  

        virtual void SetProcessPtr(void *address) 
                { fProcessPtr = address; }  
        
        virtual std::string &GetProcessName() 
                { return fProcessName; }
        virtual std::string &GetProcessMethod() 
                { return fProcessMethod; }
        

        virtual void SetProcessMethod(const char *);
        
        virtual void SetLevel(ELevel lev, unsigned short verbosity = 0u);
        virtual ELevel GetLevel() const 
                { return fLevel; }   
        virtual ELevel GetLowestLevel() const 
                { return fLowestLevel; }  
        virtual void SetVerboseLevel(unsigned short verbosity)
                { fVerbosity = verbosity; } 
        virtual unsigned short GetVerboseLevel() const 
                { return fVerbosity; }  
        
        virtual void Send();      
        virtual std::string Message() const 
                { return fCoreMsg.str() ; }   
        virtual void ClearMessage();
        
        virtual std::string Header() const 
                { return fHeader.str() ; }  
        virtual std::string Footer() const 
                { return fFooter.str() ; }  
        
        virtual LogMessage & operator<< ( LogMessage &(*pf)(LogMessage&) ) 
                { (*pf)(*this); return (*this); }   
        
        template<class T> LogMessage &operator<<(T t)
        { 
                if ( fDebug > gDebug )
                        return (*this);
                
                // it requires a new ticket to be open
                if ( fIndentation == 0 )
                        NewTicket();
                
                if ( fIsANewLine ) {
                        Indent(fCoreMsg); fIsANewLine = false;
                }
                fCoreMsg << t; 
                return (*this); 
        }       
  
}; 

LogMessage &info(LogMessage &);
LogMessage &warning(LogMessage &);
LogMessage &error(LogMessage &);
LogMessage &debug(LogMessage &);
LogMessage &dolog(LogMessage &);

LogMessage &clear(LogMessage &);    
LogMessage &nline(LogMessage &);
LogMessage &sep(LogMessage &); 

std::ostream &hline (std::ostream &);

// deprecated
LogMessage &endl(LogMessage &);

}

#endif