D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/cl_base_obj.h

/* LICENSE_BEGIN
SutoiTools library supply support for debugging, testing and 
setting good bases for you application. 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
*/

/* \file SG_TLS_cl_base.h
 * \brief Supply two basic class used by the CL_template_manager.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_CL_BASE_OBJ_H
#define SG_TLS_CL_BASE_OBJ_H

#include "SugoiTools\config.h"
//#include "xml.h"
#include <sys/stat.h>
//#include <unistd.h>
//io.h dosio.h
#include <time.h>


#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new.h"
#endif 

namespace SGE{
//class _SG_TLS_EXPORT CL_BASE_OBJ_FILE;
//class _SG_TLS_EXPORT CL_BASE_OBJ;

enum TMANAGER_TYPE{
          TMANAGER_DEFAULT,
          TMANAGER_FILE
};


enum SGE_OBJ_TYPE{
           SGE_TYPE_int,
           SGE_TYPE_uint,
           SGE_TYPE_bool,
           SGE_TYPE_char,
           SGE_TYPE_uchar,
           SGE_TYPE_charArr,
           SGE_TYPE_string,
          SGE_TYPE_float,
           SGE_TYPE_double
};
 
SGE_OBJ_TYPE WhatType(int                         &_Val);
SGE_OBJ_TYPE WhatType(unsigned int      &_Val);
SGE_OBJ_TYPE WhatType(float                       &_Val);
SGE_OBJ_TYPE WhatType(double            &_Val);
SGE_OBJ_TYPE WhatType(bool                        &_Val);
SGE_OBJ_TYPE WhatType(unsigned char &_Val);
SGE_OBJ_TYPE WhatType(char                        &_Val);
SGE_OBJ_TYPE WhatType(char *            _Val);
SGE_OBJ_TYPE WhatType(std::string       &_Val);
 

template <typename IDType=std::string>
          class CL_BASE_OBJ
{
public:

          _SG_TLS_INLINE 
                    CL_BASE_OBJ()
                    {};

          _SG_TLS_INLINE 
                    CL_BASE_OBJ(const IDType & _ID)
                    {
                              ID = _ID;
                    /*        if (typeid(IDType) == typeid(std::string))
                              {
                                        std::string TmpStr = ToCharStr(ID, TmpStr);
                                        StringToUpper(TmpStr);
                    */
                    };

          _SG_TLS_INLINE 
                    ~CL_BASE_OBJ(){};

          _SG_TLS_INLINE 
                    const IDType &      
                              GetID()const
                              {return ID;};

          _SG_TLS_INLINE 
                    const std::string
                              GetIDStr()
                              {return ToCharStr(ID);};

          _SG_TLS_INLINE virtual 
                    const std::string
                              GetValStr()
                              {return "Function not Defined!!";};
          
protected:
          _SG_TLS_INLINE 
                    void 
                    SetID(const IDType & _ID)
                              {ID = _ID;}

          IDType ID;                    
          template<class T, typename P>  friend class CL_TEMPLATE_OBJECT_MANAGER;
};



class _SG_TLS_EXPORT CL_BASE_OBJ_FILE : 
          public virtual CL_BASE_OBJ<std::string>
{
 public:
          _SG_TLS_INLINE 
                    CL_BASE_OBJ_FILE(const std::string & _Name);

    _SG_TLS_INLINE 
                    ~CL_BASE_OBJ_FILE();
 
    _SG_TLS_INLINE 
                    bool 
                    IsLoaded()const;

    _SG_TLS_INLINE virtual 
                    int Load();

    virtual _SG_TLS_INLINE int UnLoad();
    _SG_TLS_INLINE 
                    const std::string & GetPath()const;

          _SG_TLS_INLINE const std::string & GetExtension()const;

          _SG_TLS_INLINE const std::string GetFullName()const;

#if _SG_TLS_FILE_TEST

          _SG_TLS_INLINE bool Exists()const;

          static bool FileExists(const std::string & _Name);

#if 0
          static bool FileCopy(const std::string & _Src, const std::string & _Dst);
          static bool FileMove(const std::string & _Src, const std::string & _Dst);
          static bool FileDelete(const std::string & _Src);
#endif

          
          _SG_TLS_INLINE bool IsFileModified();

protected:
          struct stat * FileAttrib;               //<! Create a file attribute structure, store date size and other...
#endif

protected:
          _SG_TLS_INLINE                
                    void      ParseFileName();        

          std::string                             Path;               
          std::string                             Extension;  

private:
          bool                                    Loaded; 
};

};//namespace
#if SG_TLS_MEMORY_MANAGER
          #include "SugoiTools\debug_new_off.h"//Must be the last....
#endif 

#endif //SG_TLS_CL_BASE_OBJ_H

---