D:/WorkDir/SugoiProjects/SugoiTools/include/SugoiTools/files.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_files.h
 * \brief Supply two basic class used by the CL_template_manager.
 * \author Yannick Allusse
*/
#ifndef SG_TLS_FILES_H
#define SG_TLS_FILES_H

#include "SG_TLS_config.h"
#include "SG_TLS_cl_base_dbl_obj.h"
#include <sys/stat.h>
#include <time.h>

#if SG_TLS_MEMORY_MANAGER
          #include "SG_TLS_debug_new.h"
#endif 

namespace SGE{

template <typename IDType2=int>
class _SG_TLS_EXPORT CL_BASE_OBJ_FILE : 
          public virtual CL_BASE_DBL_OBJ<std::string, IDType2>
{
 public:
          _SG_TLS_INLINE 
                    CL_BASE_OBJ_FILE(const std::string & _Name)
                    : CL_BASE_DBL_OBJ<std::string, IDType2>(_Name)
          {
                    //_Type = TMANAGER_FILE;
                    Loaded = false;
                    ParseFilePath(_Name, (std::string*)&(CL_BASE_OBJ<std::string>::ID), &Path);
                    ParseFileType((std::string)CL_BASE_OBJ<std::string>::ID, (std::string*)&(CL_BASE_OBJ<std::string>::ID), &Extension);

                    #if _SG_TLS_FILE_TEST
                              FileAttrib = NULL;
                    #endif
          }

    _SG_TLS_INLINE 
                    ~CL_BASE_OBJ_FILE()
          {
                    if (Loaded)
                              UnLoad();
          }
 
    _SG_TLS_INLINE 
                    bool 
                    IsLoaded()const
                    {         return Loaded;      }

    _SG_TLS_INLINE virtual 
                    int Load()
                    {         
                    #if _SG_TLS_FILE_TEST
                              //get file attribs
                              FileAttrib = new struct stat;
                              stat(GetFullName().data(), FileAttrib);
                              //==================================
                    #endif

                              Loaded = true;      
                              return 1;
                    }

    _SG_TLS_INLINE virtual
                    int UnLoad()
                    {
                              Loaded = false;     
                              return 1;
                    }
    _SG_TLS_INLINE 
                    const std::string & GetPath()const
                    {return Path;}

          _SG_TLS_INLINE 
                    const std::string & GetExtension()const
                    {return Extension;}

          _SG_TLS_INLINE 
                    const std::string GetFullName()const
                    {return Path+ CL_BASE_OBJ<std::string>::ID+ Extension;}

#if _SG_TLS_FILE_TEST

          _SG_TLS_INLINE bool Exists()const
                    {
                              return FileExists(GetFullName());
                    }

          static bool FileExists(const std::string & _Name)
                    {
                              std::ifstream File(_Name.c_str());
                              if( File.is_open())
                              {
                                        File.close();
                                        return true;
                              }

                              return false;
                    }


#if 0
          static bool FileCopy(const std::string & _Src, const std::string & _Dst)
                    {
                              Sys File::Copy("myfile.txt", "copyofmyfile.txt");  
                    }
          
          static bool FileMove(const std::string & _Src, const std::string & _Dst)
                    {
                    }
          static bool FileDelete(const std::string & _Src)
                    {
                    }
#endif

          
          _SG_TLS_INLINE bool IsFileModified()
                    {
                              if (!Loaded)
                              {
                                        SG_NOTICE_LOG("File Not Loaded");
                                        return false;
                              }

                              struct stat NewFileAttrib;
                              stat(GetFullName().data(), &NewFileAttrib);// get the attributes of afile.txt

                              struct tm* OrigFileClock                = gmtime(&(FileAttrib->st_mtime));
                              struct tm* CurFileClock                           = gmtime(&(NewFileAttrib.st_mtime));// Get the last modified time and put it into the time structure
                              

                              if (CurFileClock->tm_sec =! OrigFileClock->tm_sec) /* seconds after the minute - [0,59] */
                                        return true;
                              if (CurFileClock->tm_min =! OrigFileClock->tm_min)/* minutes after the hour - [0,59] */
                                        return true;
                              if (CurFileClock->tm_hour =! OrigFileClock->tm_hour) /* hours since midnight - [0,23] */
                                        return true;
                    #if 0//???see later...sec, min and hours should be far enought to test in our case...     
                              if (CurFileClock->tm_mday =! OrigFileClock->tm_mday)/* day of the month - [1,31] */
                                        return true;
                              if (CurFileClock->tm_mon =! OrigFileClock->tm_mon)/* months since January - [0,11] */
                                        return true;
                              if (CurFileClock->tm_year =! OrigFileClock->tm_year)/* years since 1900 */
                                        return true;
                              if (CurFileClock->tm_wday =! OrigFileClock->tm_wday)/* days since Sunday - [0,6] */
                                        return true;
                              if (CurFileClock->tm_yday =! OrigFileClock->tm_yday)/* days since January 1 - [0,365] */
                                        return true;
                              if (CurFileClock->tm_isdst =! OrigFileClock->tm_isdst) /* daylight savings time flag */
                                        return true;
                    #endif
                              return false;
                    }

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

protected:
          _SG_TLS_INLINE                
                    void      ParseFileName()
                    {
                              ParseFilePath(ID, &Path, &ID);
                              ParseFileType(ID, &ID, &Extension);
                    }

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

private:
          bool                                    Loaded; 
};

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

#endif //SG_TLS_CL_BASE_OBJ_H

---