D:/WorkDir/SugoiProjects/SugoiTracer/include/SugoiTracer/timer.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_TIMER_H
#define _SG_TRC_TIMER_H

#ifdef __cplusplus

#include <SugoiTracer\config.h>
#include <SugoiTools\xml.h>



#ifdef _WIN32
        #include <winsock.h>
#else
        #include <sys/h>
#endif

#include <Time.h>
#include <sys/timeb.h> 

namespace SG_TRC{

class  _SG_TRC_DLL_EXPORT CL_Virtual_Record :
                public CL_XML_OBJ
{
public :
        CL_Virtual_Record(void)
                :CL_XML_OBJ("vrecord")
                {Clear();};             

        CL_Virtual_Record(const CL_Virtual_Record &_Rec2)
                :CL_XML_OBJ("vrecord")
                {Clear();};     

        CL_Virtual_Record(const long T)
                :CL_XML_OBJ("vrecord")
                {Clear();};

        virtual ~CL_Virtual_Record(void){Clear();};
        
        virtual void Clear(){};                         
        virtual void SetToMax(){};
        virtual void SetToMin(){};

          //arithmetic operators
        _SG_TRC_INLINE virtual CL_Virtual_Record&   operator  =( const long T){return *this;};                          
          _SG_TRC_INLINE virtual CL_Virtual_Record&   operator  =( const CL_Virtual_Record &_Rec2){return *this;};
          // _SG_TRC_INLINE CL_Virtual_Record&   operator  =( const ST_Timeval &_Timeval);
          _SG_TRC_INLINE virtual bool                           operator !=( const CL_Virtual_Record &_Rec2){return false;};
        //  _SG_TRC_INLINE virtual bool                         operator !=( const long T)= 0;//!< operator !=.
          _SG_TRC_INLINE virtual bool                           operator ==( const CL_Virtual_Record &_Rec2){return false;};
    //  _SG_TRC_INLINE virtual bool                             operator ==( const long T)= 0;//!< operator ==.
          _SG_TRC_INLINE virtual bool   operator < ( const CL_Virtual_Record &_Rec2){return false;};
      _SG_TRC_INLINE virtual bool   operator > ( const CL_Virtual_Record &_Rec2){return false;};

          _SG_TRC_INLINE virtual CL_Virtual_Record&   operator +=( const CL_Virtual_Record &_Rec2){return *this;};
      _SG_TRC_INLINE virtual CL_Virtual_Record&   operator -=( const CL_Virtual_Record &_Rec2){return *this;};
      _SG_TRC_INLINE virtual CL_Virtual_Record&   operator /=( const long T){return *this;};
      _SG_TRC_INLINE virtual CL_Virtual_Record&   operator *=( const long T){return *this;};

          _SG_TRC_INLINE virtual CL_Virtual_Record   operator  +( const CL_Virtual_Record &_Rec2){return *this;};
          _SG_TRC_INLINE virtual CL_Virtual_Record   operator  -( const CL_Virtual_Record &_Rec2){return *this;};
          _SG_TRC_INLINE virtual CL_Virtual_Record   operator  /( const long T){return *this;};
          _SG_TRC_INLINE virtual CL_Virtual_Record   operator  *( const long T){return *this;};
          //========================      
          
          _SG_TRC_INLINE virtual void Run(void){};
          _SG_TRC_INLINE virtual long GetValue(void){return 0;};
          _SG_TRC_INLINE virtual void SetValue(const long L){};
          _SG_TRC_INLINE virtual  std::string GetStr(bool _Approxmimate=true){return "";};
      _SG_TRC_INLINE virtual void Print(){};                                                    
          
#if _SG_TLS_XML
public:
        virtual TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT, std::string _Name =""){return NULL;};
        virtual TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT, std::string _Name=""){return NULL;};
#endif

};



typedef struct timeval ST_Timeval;
class _SG_TRC_DLL_EXPORT CL_TimerVal : public CL_Virtual_Record
{
public :

          long    tv_sec;                       
      long    tv_usec;                  
          
 
      CL_TimerVal(void);                                                
          CL_TimerVal(const CL_TimerVal &Time2);        
          CL_TimerVal(const CL_Virtual_Record &_Rec2);
          CL_TimerVal(const ST_Timeval &_Timeval);
          CL_TimerVal(const long T);                            
      ~CL_TimerVal(void){};                                             
          void Clear();                         
          void SetToMax();
          void SetToMin();

          //arithmetic operators
          _SG_TRC_INLINE CL_TimerVal&   operator  =( const long T);                             
          _SG_TRC_INLINE CL_TimerVal&   operator  =( const CL_TimerVal &Time2);
//        _SG_TRC_INLINE CL_TimerVal&   operator  =( const CL_Virtual_Record *Time2);//!< operator =.
          _SG_TRC_INLINE CL_TimerVal&   operator  =( const ST_Timeval &_Timeval);
          _SG_TRC_INLINE bool                           operator !=( const CL_TimerVal &Time2);
          //_SG_TRC_INLINE bool                         operator !=( const long T)= 0;
          _SG_TRC_INLINE bool                           operator ==( const CL_TimerVal &Time2);
          //_SG_TRC_INLINE bool                         operator ==( const long T)= 0;
      _SG_TRC_INLINE bool   operator < ( const CL_TimerVal &Time2);
      _SG_TRC_INLINE bool   operator > ( const CL_TimerVal &Time2);

          _SG_TRC_INLINE CL_TimerVal&   operator +=( const CL_TimerVal &Time2);
      _SG_TRC_INLINE CL_TimerVal&   operator -=( const CL_TimerVal &Time2);
      _SG_TRC_INLINE CL_TimerVal&   operator /=( const long T);
      _SG_TRC_INLINE CL_TimerVal&   operator *=( const long T);

          _SG_TRC_INLINE CL_TimerVal   operator  +( const CL_TimerVal &Time2)const;
          _SG_TRC_INLINE CL_TimerVal   operator  -( const CL_TimerVal &Time2)const;
          _SG_TRC_INLINE CL_TimerVal   operator  /( const long T)const;
          _SG_TRC_INLINE CL_TimerVal   operator  *( const long T)const;
          //========================      
          
      //_SG_TRC_INLINE void GetSysTime(void);                                   //!< Get the current system time from boot.
          _SG_TRC_INLINE void AddTimeUs(const unsigned int _time);
          _SG_TRC_INLINE void AddTimeMs(const unsigned int _time);
          _SG_TRC_INLINE long GetValue(void);                                   
          _SG_TRC_INLINE std::string GetStr(bool _Approxmimate=true)const;
      _SG_TRC_INLINE void Print();  
          _SG_TRC_INLINE void Run(CL_TimerVal * StopTime=NULL);
          //to put extern
        bool succes;            //set if the function traced was successfull
        int returnValue;        //store the return value.
          //=================

#if _SG_TLS_XML
public:
        TiXmlElement* XMLLoad(TiXmlElement* _XML_ROOT, std::string _Name ="");
        TiXmlElement* XMLSave(TiXmlElement* _XML_ROOT, std::string _Name="");
#endif
};

extern "C"
{
#endif

_SG_TLS_EXPORT int Ygettimeofday(struct timeval * tp);
_SG_TLS_EXPORT void cleartimeval(struct timeval * t1);

};//namespace SG_TRC
#ifdef __cplusplus
}//to export this few functions to 'C'
#endif

#endif//_SG_TRC_TIMER_H

---