TestLOG.C

Go to the documentation of this file.

#include "TObject.h"
#include "LogMessage.h"

class TestLOG_0
{
protected:
        LogMessage fLog;
public:
        TestLOG_0() : fLog("TestLOG_0") {;}
        virtual ~TestLOG_0()
                {;}
        
        void ToLog_0();
};

void TestLOG_0::ToLog_0()
{
        Int_t i = 0;
        
        // set the method and open a log ticket
        fLog.SetProcessMethod("ToLog_0");
        fLog << debug  << "IN BASE " << nline;
        
        // ... do something
        fLog << info  << i << " set to 0 " << nline;
        // ... do something

        fLog << debug  << "OUT BASE " << nline;
        fLog << dolog;
}

class TestLOG_1 : public TestLOG_0
{
public:
        TestLOG_1() { fLog.GetProcessName() = "TestLOG_1" ; }
        virtual ~TestLOG_1()
                {;}
        
        virtual void ToLog_1();
};

void TestLOG_1::ToLog_1()
{
        Int_t i = 1;
        
        // set the method and open a log ticket
        fLog.SetProcessMethod("ToLog_1");
        fLog << debug  << "IN LEVEL 1 " << nline;
        
        fLog << debug  << "Call of BASE " << nline;
        TestLOG_0::ToLog_0();
        fLog << debug  << "end Call of BASE " << nline;
        
        // ... do something
        fLog << error << i << " cannot be set to 1 " << nline;
        // ... do something
        
        // sent all the collected messages to the LogCollector
        fLog << debug  << "OUT LEVEL 1 " << nline;
        fLog << dolog;
}

class TestLOG_2 : public TestLOG_1
{
public:
        TestLOG_2() { fLog.GetProcessName() = "TestLOG_2" ; }
        virtual ~TestLOG_2()
        {;}
        
        virtual void ToLog_2();
};

void TestLOG_2::ToLog_2()
{
        Int_t i = 2;
        
        // set the method and open a log ticket
        fLog.SetProcessMethod("ToLog_2");
        if ( fLog.IsDebug(2) ) {
                fLog << "It could be boring the send debug lines line by line " << nline;
                fLog << "thus, it could be done using IsDebug() " << nline;
                fLog << "IN LEVEL 2 " << nline;
        }
        TestLOG_1::ToLog_1();
        
        // ... do something
        fLog.SetLevel(LogMessage::kWarning,1);
        fLog << i << " cannot be set to 2 " << nline;
        fLog.SetLevel(LogMessage::kInfo,0);     
        // ... do something
        
        // sent all the collected messages to the LogCollector
        if ( fLog.IsDebug(2) ) {
                fLog << "It could be boring the send debug lines line by line " << nline;
                fLog << "thus, it could be done using IsDebug() " << nline;
                fLog << "OUT LEVEL 2 " << nline;
        }
        fLog << dolog;
}

class TestLOG_3 : public TestLOG_2
{
public:
        TestLOG_3() { fLog.GetProcessName() = "TestLOG_3" ; }
        virtual ~TestLOG_3()
        {;}
        
        virtual void ToLog_3();
};

void TestLOG_3::ToLog_3()
{
        Int_t i = 3;
        
        // set the method and open a log ticket
        fLog.SetProcessMethod("ToLog_3");
        
        TestLOG_2::ToLog_2();
        
        // ... do something
        fLog << i << " cannot be set to 3 " << nline;
        // ... do something
        
        // sent all the collected messages to the LogCollector
        fLog << dolog;
}

#include "LogCollector.h"
#include "CentralLog.h"

void TestLOG()
{
        TestLOG_0 lev0; TestLOG_1 lev1; TestLOG_2 lev2; TestLOG_3 lev3; 
        
        printf("\n*************** Log cout, not depth *************** \n");
        LogMessage::SetLogParameters(0,1);
/*  means :
        LogMessage::gDebug               = 0; 
        LogMessage::gkMaxDepth   = 1;
        LogMessage::gkAutoClear  = 7; */
        
        // log messages, no depth
        lev0.ToLog_0();
        // log messages, one depth's call
        lev1.ToLog_1();
        // log messages, two depth' calls
        lev2.ToLog_2();
        // log messages, three depth' calls
        lev3.ToLog_3();

        printf("\n*************** Log cout, and depth *************** \n");
        LogMessage::SetLogParameters();
/*  means :
        LogMessage::gDebug               = 0; 
        LogMessage::gkMaxDepth   = 5;
        LogMessage::gkAutoClear  = 7; */

        // log messages, no depth
        lev0.ToLog_0();
        // log messages, one depth's call
        lev1.ToLog_1();
        // log messages, two depth' calls
        lev2.ToLog_2();
        // log messages, three depth' calls
        lev3.ToLog_3();
                
        // A log collector is created to collector logs in a file
        // WARNING !! the user should notify if the new collector is owned by teh CentralLog with 
        // OStreamCollector("TEST.log",true)
        // which is the default behavior. In this case CentralLog deletes the Collector
        // if set to false, the user should take of deleting the collector
        OStreamCollector *test_collector = new OStreamCollector("TestLOG.log"); 
        CentralLog::theCentralLog()->Add( test_collector ) ;
        CentralLog::theCentralLog()->ChangeCollector(std::string("TestLOG.log"));
        
        printf("\n*************** Log file, and depth *************** \n");

        // log messages, no depth
        lev0.ToLog_0();
        // log messages, one depth's call
        lev1.ToLog_1();
        // log messages, two depth' calls
        lev2.ToLog_2();
        // log messages, three depth' calls
        lev3.ToLog_3();
        
        printf("\n************** Log all to black hole ************** \n");
        // messages are now sent to a black hole !
        CentralLog::theCentralLog()->ChangeCollector(std::string("Null"));

        // log messages, no depth
        lev0.ToLog_0();
        // log messages, one depth's call
        lev1.ToLog_1();
        // log messages, two depth' calls
        lev2.ToLog_2();
        // log messages, three depth' calls
        lev3.ToLog_3();
        
        printf("\n************** Cout and debug info ************** \n");
        CentralLog::theCentralLog()->ChangeCollector(std::string("cout"));
        LogMessage::SetLogParameters(2);
/*  means :
         LogMessage::gDebug               = 2; 
         LogMessage::gkMaxDepth   = 5;
         LogMessage::gkAutoClear  = 7; */
        
        // log messages, no depth
        lev0.ToLog_0();
        // log messages, one depth's call
        lev1.ToLog_1();
        // log messages, two depth' calls
        lev2.ToLog_2();
        // log messages, three depth' calls
        lev3.ToLog_3();
}