ADFLogMessage.cpp

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.             *
 ***************************************************************************/
 
#include "ADFLogMessage.h"
#include "ADFLogCollector.h"

// anonymous namespace to protect them so that they are defined only in this file
namespace {
  const char ci = ' ';
  const char gkIndent[] = {ci,ci,ci,ci,ci,ci,ci,ci,ci,ci};
//   const char gkIndent[] = {'-','-','-','-',' ',' ',' ',' ',' ',' '};  
  
  const char gLevel[] = {'E','w','i','o'};
}

using namespace ADF;

short LogMessage::gkMaxDepth  = 5;
short LogMessage::gkAutoClear = 7;

short LogMessage::gDebug = 0; 

LogMessage::LogMessage(const char *pname, unsigned int pid) : 
        fProcessName(pname), 
        fProcessMethod(""), 
        fProcessMethodTicket(""),
        fProcessID(pid),
        fProcessPtr(0x0),
        fDebug(-1),
        fTicketNumber(0u),
        fLevel(kInfo), 
        fLowestLevel(kInfo), 
        fVerbosity(0u),
        fIndentation(0u),
        fRealIndentation(0u),
        fIsANewLine(true),
        fHeader(),
        fCoreMsg(),
        fFooter()
{
        SetProcessPtr(this);
} 

LogMessage::~LogMessage() 
{
        ;
}

void LogMessage::SetLogParameters(short global_debug_level, short max_indent, short max_before_clear)
{
        if ( global_debug_level < 0 )
                gDebug = 0;
        else
                gDebug = global_debug_level;
                
        if ( max_indent < 1 ) 
                gkMaxDepth = 1;
        else 
                gkMaxDepth = max_indent;
        
        if ( max_before_clear <= gkMaxDepth )
                gkAutoClear = gkMaxDepth + 2;
        else 
                gkAutoClear = max_before_clear;
}

void LogMessage::SetDebug(short global_debug_level)
{
        if ( global_debug_level < 0 )
                gDebug = 0;
        else
                gDebug = global_debug_level;
}

void LogMessage::Indent()
{ 
        // still ok to indent
        if ( fIndentation < gkMaxDepth ) 
                fIndentation++;
        
        // AuoClear called, probably a SetProcessMethod()/dolog not called properly
        if ( fRealIndentation > gkAutoClear ) {
                std::string tmp = fProcessMethod; fProcessMethod = fProcessMethodTicket;
                SetLevel(kWarning, 1);
                (*this) << "Automatic clear called since max value for depth calls " 
                                << gkAutoClear << " reached. Probably a missing SetProcessMethod()/dolog bracket " << nline;
                fIndentation = 1;
                Send();
                fProcessMethod = tmp;
                DoClear();
        }
        else fRealIndentation++;
}

void LogMessage::DoClear() 
{ 
        fCoreMsg.str(""); 
        fDebug = -1;
        fLevel = kInfo;
        fLowestLevel = kInfo;   
        fVerbosity = 0;
        fIndentation = fRealIndentation = 0; fIsANewLine = true;
}

void LogMessage::ClearMessage() 
{ 
        // a new ticket is open, force sending the message 
        if ( fIndentation ) {
                fIndentation = 1;
                Send();
        }
        else DoClear();
}

void LogMessage::SetLevel(ELevel lev, unsigned short verbosity)
{       
        if ( lev == fLevel && verbosity == fVerbosity )
                return;

        fLevel = lev; fVerbosity = verbosity;
        
        if ( fLevel < fLowestLevel ) 
                fLowestLevel = fLevel;
        
        // modification of the internal state on a single line
        if ( !fIsANewLine ) 
                (*this) <<  nline;

        (*this) << "|" << gLevel[fLevel] << "," << fVerbosity << "|" << nline;          
}

void LogMessage::NewTicket()
{
        // keep track of the method that has started the ticket.
        fProcessMethodTicket = fProcessMethod;

        fHeader.str("");  
        fHeader << "[+[#" << fTicketNumber << "] |" << gLevel[fLevel] << "," << fVerbosity << "| " 
                        << GetProcessName() << "::" << GetProcessMethod() << " : " << fProcessPtr << " ]" << std::endl ;
        
        // set footer
        fFooter.str("");  
        fFooter << "[-[#" << fTicketNumber << "] "
                                          << GetProcessName() << "::" << GetProcessMethod() << " : " << fProcessPtr << " ]" << std::endl ;
                
        // re-start indentation
        fIndentation = fRealIndentation  = 0; 
        Indent();
}

void LogMessage::SetProcessMethod(const char *method)
{
        if ( fIndentation == 0 ) {
                fProcessMethod = method;
                NewTicket();
        }
        else {
                fProcessMethod = method;
                if ( !fIsANewLine ) 
                        (*this) << nline;
                (*this) << "[" << " -> ::" << fProcessMethod << " ]" << nline;
                Indent();
        }
}

void LogMessage::Send() 
{ 
        // nothing to be sent ! ... maybe an idea to have a flag to control this 
        //if ( fCoreMsg.tellp() < 0 ) 
        //      return;
        fDebug = -1;

        if ( fIndentation == 0 )
                return;
        
        if ( fIndentation == 1 ) {
                
                LogCollector::theCollector()->DoCollect((*this));       
                DoClear();
                
                fTicketNumber++;
        }
        else fIndentation--;
}      

void LogMessage::Indent(std::ostream &o)
{
        if ( fIndentation )
                o.write(gkIndent,fIndentation);
}           
        
std::ostream &ADF::hline(std::ostream &o)
{
        o << "--------------------------------------------------------------------------------\n";
        return o;
} 

ADF::LogMessage &ADF::info(ADF::LogMessage &log)
{ 
        log.SetLevel(LogMessage::kInfo,log.GetVerboseLevel());
        return log;  
}

ADF::LogMessage &ADF::warning(ADF::LogMessage &log)
{
        log.SetLevel(ADF::LogMessage::kWarning,log.GetVerboseLevel());
        return log; 
}

ADF::LogMessage &ADF::error(ADF::LogMessage &log)
{ 
        log.SetLevel(ADF::LogMessage::kError,log.GetVerboseLevel());
        return log;
} 

ADF::LogMessage &ADF::debug(ADF::LogMessage &log)
{ 
        log.fDebug = 1;
        return log;
}

ADF::LogMessage &ADF::dolog(ADF::LogMessage &log)
{ 
        log.Send(); 
        return log; 
}
 
ADF::LogMessage &ADF::clear(ADF::LogMessage &log)
{ 
        log.ClearMessage();
        return log; 
} 

ADF::LogMessage &ADF::nline(ADF::LogMessage &log)
{ 
        log.fDebug = -1; 
        
        if ( log.fIsANewLine )
                return log;
        
        log.fCoreMsg << "\n"; log.fIsANewLine = true;
        return log;
} 

ADF::LogMessage &endl(ADF::LogMessage &log)
{ 
        return nline(log);
}