D:/WorkDir/SugoiProjects/SugoiTracer/include/SugoiTracer/class.h

Go to the documentation of this file.

/* LICENSE_BEGIN
SutoiTracer library supply support profiling functions, class, or evet simple 
piece of code. It is part of the SugoiEngine project.
Copyright (C) 2006 Allusse Yannick (yannick dot allusse at laposte dot net)

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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
LICENSE_END
*/
#ifndef _SG_TRC_CLASS_H
#define _SG_TRC_CLASS_H

#include "SugoiTracer\config.h"

#ifdef __cplusplus
        #include "SugoiTracer\timer.h"
        #include "SugoiTracer\function.h"
        #include "SugoiTracer\appli.h"
        #include <Time.h>
        #include <sys/timeb.h> 
        #include <SugoiTools\cl_base_obj.h>
        #include <SugoiTools\cl_template_manager.h>


namespace SG_TRC{

//template <typename TracerType> class CL_FUNCT_TRC;

template <typename TracerType= SG_TRC_Default_Trc_Type>
        class CL_CLASS_TRACER:
                public SGE::CL_XML_BASE_OBJ<std::string>
{
public:
#if _SG_TLS_SMARTPTR
        typedef typename CL_CLASS_TRACER<TracerType>*   TplSmartP;
#else
        typedef typename CL_CLASS_TRACER<TracerType> *                                  TplSmartP;
#endif
        /*
#if _SG_TLS_SMARTPTR
        typedef typename SGE::CSmartPtr<CL_FUNCT_TRC<TracerType> >                      TplFctP;
        typedef typename SGE::CSmartPtr<CL_CLASS_TRC<TracerType> >                      TplClassP;
        
#else
        typedef CL_FUNCT_TRC<TracerType> *                      TplSmartP;
        typedef CL_CLASS_TRC<TracerType> *                      TplClassP;
#endif*/
        typedef TplSmartP                                                       TplHdle;

        //Class Name
        SGE::CL_XML_MNGR<CL_FUNCT_TRC<TracerType> > * FunctionsManager;
        
        CL_CLASS_TRACER(std::string _Name, TTCL_APPLI_TRACER<TracerType> * _ParentAppliTracer = NULL);
        ~CL_CLASS_TRACER();

        void Clear();

        bool TracingEnable;

        void SetParrentAppliTracer(TTCL_APPLI_TRACER<TracerType> * _ParentAppliTracer);
        CL_FUNCT_TRC<TracerType> * AddFunct(std::string _FunctName);
        int GetAllRecordNumbers();

        int Process();
        TracerType *TotalTime;

private:
        TTCL_APPLI_TRACER<TracerType> * ParentAppliTracer;

#if _SG_TLS_XML
public:
        _SG_TLS_INLINE TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT);
        _SG_TLS_INLINE TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT);
#endif
};

//================================================================
//===========                    CODE           ==============================
//================================================================
/*
template <typename TracerType> CL_CLASS_TRACER<TracerType>::CL_CLASS_TRACER(std::string _Name):CL_BASE_OBJ(_Name)
{
        TracingEnable = true;
        SetParrentAppliTracer(NULL);
        FunctionsManager = new CL_TEMPLATE_OBJECT_MANAGER <CL_FUNCT_TRC<TracerType>> (NULL);
        TotalTime = new TracerType();
}
*/
template <typename TracerType> 
        CL_CLASS_TRACER<TracerType>::CL_CLASS_TRACER(std::string _Name, TTCL_APPLI_TRACER<TracerType> * _ParentAppliTracer)
        :CL_XML_BASE_OBJ<std::string>(_Name, "Class")
{
        TracingEnable = true;
        SetParrentAppliTracer(_ParentAppliTracer);
        FunctionsManager = new CL_XML_MNGR<CL_FUNCT_TRC<TracerType> > (NULL, "FunctionManager", "function", "name");
        TotalTime = new TracerType();
}

template <typename TracerType> CL_CLASS_TRACER<TracerType>::~CL_CLASS_TRACER()
{
        delete (FunctionsManager);
        delete (TotalTime);
}

template <typename TracerType> void CL_CLASS_TRACER<TracerType>::Clear()
{
        TotalTime->Clear();
        //we clear all function, but we don't delete them cause some of them are statics...
        CL_XML_MNGR<CL_FUNCT_TRC<TracerType> >::iterator iFunct;
        for (iFunct = FunctionsManager->GetFirstIter(); iFunct != FunctionsManager->GetLastIter(); iFunct++)
                (*iFunct).second->Clear();

}


template <typename TracerType> void CL_CLASS_TRACER<TracerType>::SetParrentAppliTracer(TTCL_APPLI_TRACER<TracerType> * _ParentAppliTracer)
{
        ParentAppliTracer = _ParentAppliTracer;
}

template <typename TracerType> CL_FUNCT_TRC<TracerType> * CL_CLASS_TRACER<TracerType>::AddFunct(std::string _FunctName)
{
        CL_FUNCT_TRC<TracerType> * TempFunct = FunctionsManager->Get(_FunctName);

        if (TempFunct)
                return TempFunct;

        //else we add it
        FunctionsManager->Add(_FunctName);
        TempFunct = FunctionsManager->GetLastAdded();
        SG_Assert(TempFunct, "CL_CLASS_TRACER<TracerType>::AddFunct() : Error Adding new function." );

        TempFunct->SetParrentClass(this);

        return TempFunct;
}

template <typename TracerType> int CL_CLASS_TRACER<TracerType>::Process(void)
{
        int i =0;
        CL_XML_MNGR<CL_FUNCT_TRC<TracerType> >::iterator iFct;
        for ( iFct = FunctionsManager->GetFirstIter() ; iFct != FunctionsManager->GetLastIter( ) ; iFct++ )
        {
                if ((*iFct).second->IsModified())
                {
                        (*iFct).second->Process();
                        i++;
                }
        }
        return i;
}


template <typename TracerType> int CL_CLASS_TRACER<TracerType>::GetAllRecordNumbers()
{
        int i =0;
        CL_XML_MNGR<CL_FUNCT_TRC<TracerType>>::iterator iFct;
        for ( iFct = FunctionsManager->GetFirstIter.begin() ; iFct != FunctionsManager->GetLastIter.end( ) ; iFct++ )
        {
                i+= (*iFct).second->GetAllRecordNumbers();
        }
        return i;
}

        
#if _SG_TLS_XML
template <typename TracerType> TiXmlElement* CL_CLASS_TRACER<TracerType>::XMLLoad(TiXmlElement* _XML_ROOT)
{
        SG_Assert(_XML_ROOT, "No XML root");

        //name already read.

        //load functions list
        FunctionsManager->XMLLoad(_XML_ROOT);

        //affect the function pointer to all members of the list...
        
        TotalTime->XMLLoad(_XML_ROOT, "TotalTime");

        return _XML_ROOT;
}

template <typename TracerType>
TiXmlElement* 
CL_CLASS_TRACER<TracerType>::XMLSave(TiXmlElement* _XML_ROOT)
{
        SG_Assert(_XML_ROOT, "No XML root");
        
        //list of class benched
        FunctionsManager->XMLSave( _XML_ROOT);

        //TotalTime
        TotalTime->XMLSave(_XML_ROOT, "TotalTime");

        return _XML_ROOT;
}
#endif
//================================================================
//================================================================
//================================================================



};//namespace SG_TRC

#endif //__cplusplus

#endif//_SG_TRC_CLASS_H

---