• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMFileSystemManager.h

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.


#ifndef __PCM_FILESYSTEMMANAGER_H__
#  define __PCM_FILESYSTEMMANAGER_H__

//
// Inner includes
//

#  include "PCMPremeditations.h"

#  include "PCMSingleton.h"

#  include "PCMException.h"

#  include "PCMLogger.h"

#  include "PCMContainer.h"

#  include "PCMPointer.h"

//
// Outer includes
//

#  include <string>

#  include <list>

#  include <queue>

#  include <stack>

//
// Scripting bind includes (for Squirrel)
//

#  include <squirrel/squirrel.h>
#  include <squirrel/sqstdio.h>
#  include <squirrel/sqstdaux.h>
#  include <squirrel/sqplus.h>

namespace ParCompMark
{

  class FileSystemManager:public Singleton < FileSystemManager >
  {

        //
        // Unit test class
        //
#  ifdef PARCOMPMARK_TEST
        friend class ParCompMarkTest::TestFileSystemManager;
#  endif

        //
        // Scripting binding (for Squirrel)
        //



   public:static void squirrelGlue()
        {
         ::SqPlus::SQClassDef < FileSystemManager >
                (_T("FileSystemManager")).staticFunc(&FileSystemManager::getInstance,
                                                  _T("getInstance")).func(&FileSystemManager::existsDataFile,
                                                                          _T("existsDataFile"));
        }


        //
        // Enumerations
        //

   public:

        enum FileOperation
        {

         READ,

         WRITE,

         APPEND
        };

        //
        // Typedefs
        //

   public:

        typedef Pointer < FILE,
        Mutex > CFilePointer;

        typedef Pointer < std::fstream,
        Mutex > CppFilePointer;

        //
        // Class constants
        //



   public:

        static const u32 MAX_PATH;

        static const std::string PATH_SEPARATOR;


        //
        // Variables
        //



   protected:

        bool mInitialized;

        std::string mAppDirectory;

        std::string mDataDirectory;

        std::string mHomeDirectory;

        std::string mCurrentDirectory;

        std::string mIniFile;


        //
        // Constructors & destructor
        //



   public:

        FileSystemManager(const std::string & appDirectory =
                         "~/.ParCompMark/", const std::string & iniFile = "parcompmark.ini");

        virtual ~ FileSystemManager();


        //
        // Getters & setters
        //



   public:

        const bool & getInitialized() const;

        const std::string & getAppDirectory() const;

        void setAppDirectory(const std::string & appdirectory);

        const std::string & getDataDirectory() const;

        void setDataDirectory(const std::string & datadirectory);

        const std::string & getHomeDirectory() const;

        const std::string & getCurrentDirectory() const;

        const std::string & getIniFile() const;


        //
        // Class methods
        //



   public:

        static FileSystemManager *getInstance();

        static void closeFile(FileSystemManager::CppFilePointer & fp);

        static void closeFile(FileSystemManager::CFilePointer & fp);


        //
        // Methods
        //



   public:

        virtual void initialize();

        virtual void finalize();

        virtual bool existsDirectory(const std::string & name) const;

        virtual bool createDirectory(const std::string & name) const;

        virtual std::string findDataDirectory() const;

        virtual bool existsLibrary(const std::string & library,
                                 const std::vector < std::string > &additionalPaths =
                                 std::vector < std::string > ())const;

        virtual std::string findLibraryPath(const std::string & library,
                                         const std::vector < std::string > &additionalPaths =
                                         std::vector < std::string > ())const;

        virtual std::list < std::string > listDirectory(const std::string & directory) const;

        virtual std::list < std::string > listDataDirectory(const std::string & directory) const;

        virtual bool existsFile(const std::string & name) const;

        virtual bool existsAppFile(const std::string & name) const;

        virtual bool existsDataFile(const char *name) const;

        virtual FileSystemManager::CFilePointer openFileC(const std::string & name,
                                                        const FileOperation & operation =
                                                        FileSystemManager::READ) const;

        virtual FileSystemManager::CFilePointer openAppFileC(const std::string & name,
                                                          const FileOperation & operation =
                                                          FileSystemManager::READ) const;

        virtual FileSystemManager::CFilePointer openDataFileC(const std::string & name,
                                                          const FileOperation & operation =
                                                          FileSystemManager::READ) const;

        virtual FileSystemManager::CppFilePointer openFileCpp(const std::string & name,
                                                          const FileOperation & operation =
                                                          FileSystemManager::READ) const;

        virtual FileSystemManager::CppFilePointer openAppFileCpp(const std::string & name,
                                                                 const FileOperation & operation =
                                                                 FileSystemManager::READ) const;

        virtual FileSystemManager::CppFilePointer openDataFileCpp(const std::string & name,
                                                                const FileOperation & operation =
                                                                FileSystemManager::READ) const;

        virtual std::string getPathDataFile(const std::string & name) const;

        virtual std::string readTextFile(const std::string & name) const;

        virtual std::string readAppTextFile(const std::string & name) const;

        virtual std::string readDataTextFile(const std::string & name) const;

   protected:

        virtual void _findHomeDirectory();

        virtual std::string _replaceHomeChar(const std::string & path) const;

        virtual std::string _translateToAbsolutePath(const std::string & path) const;

        virtual void _createAppDirectory();


  };

  //
  // Include header implementation
  //

#  include "PCMFileSystemManager_impl.h"

}

// Declare FileSystemManager class (and its enums) for SqPlus binding
DECLARE_INSTANCE_TYPE_NAME(ParCompMark::FileSystemManager, FileSystemManager);

#endif

© Copyright - 2006 (IT)² ParCompMark Dev. Team