OSDLEmbeddedFileSystemManager.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The OSDL library 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 Lesser General Public License and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_EMBEDDED_FILE_SYSTEM_MANAGER_H_
#define OSDL_EMBEDDED_FILE_SYSTEM_MANAGER_H_



#include "Ceylan.h"  // for inheritance and FileSystemManagerException


#include <string>



namespace OSDL
{



    class OSDL_DLL EmbeddedFileSystemManagerException: 
        public Ceylan::System::FileSystemManagerException
    { 
    
        public: 
        
            explicit EmbeddedFileSystemManagerException( 
                    const std::string & reason ) :
                Ceylan::System::FileSystemManagerException( reason )
            {
            
            }                               
                
    } ;




    class OSDL_DLL EmbeddedFileSystemManager: 
        public Ceylan::System::FileSystemManager, public Ceylan::Object
    {



        public:



            /*
             * No static methods exposed: the user is expected to call  
             * them from the abstract mother classes: File, Directory and
             * FileSystemManager.
             *
             * So only the pure virtual methods of FileSystemManager have
             * to be defined in this child class, that must not be abstract.
             *
             */
            
            
            
            
            // EmbeddedFileSystemManager-specific section.
            
                    

            virtual void chooseBasicSettings(
                    const std::string & organizationName,
                    const std::string & applicationName,
                    const std::string & archiveExtension = "oar",
                    bool archiveFirst = true,
                    bool includeInsertedMedia = false ) ;



            virtual bool hasWriteDirectory() const ;
            
            
            
            virtual std::string getWriteDirectory() const ;
            
            
            
            virtual void setWriteDirectory( 
                const std::string & newWriteDirectory ) ;
        
        
             
            virtual void mount( 
                const std::string & newActualFilesystemElement,
                const std::string & mountPointInVirtualTree = "",
                bool append = true ) ;
        
        
        
            virtual void umount( const std::string & actualFilesystemElement ) ;
        


            virtual std::string getMountPointFor( 
                const std::string & actualFilesystemElement ) const ;



            virtual std::list<std::string> getSearchPath() const ;





            // FileSystemManager-specific section.



            virtual bool existsAsEntry( const std::string & entryPath ) const ;



            virtual void createSymbolicLink( const std::string & linkTarget,
                const std::string & linkName ) ;



            virtual time_t getEntryChangeTime( const std::string & entryPath ) ;




            // Accessors to FilesystemManager constants.

            
            
            virtual const std::string & getRootDirectoryPrefix() const ;
    
    
    
            virtual Ceylan::Latin1Char getSeparator() const ;
    
    
    
            /*
             * Already available from FileSystemManager:
             *   - getSeparatorAsString()
             *   - getAliasForCurrentDirectory()
             *   - getAliasForParentDirectory()
             *
             */
    
    



            // File-related section.
            
            
            
            virtual Ceylan::System::File & createFile( 
                const std::string & filename, 
                Ceylan::System::OpeningFlag createFlag =
                    Ceylan::System::File::CreateToWriteBinary,
                Ceylan::System::PermissionFlag permissionFlag =
                    Ceylan::System::File::OwnerReadWrite ) ;

            
            
            virtual Ceylan::System::File & openFile( 
                const std::string & filename, 
                Ceylan::System::OpeningFlag openFlag 
                    = Ceylan::System::File::OpenToReadBinary ) ;
            


            virtual std::string getActualLocationFor( 
                const std::string & filename ) const ;

                
                
            virtual bool existsAsFileOrSymbolicLink( 
                const std::string & filename ) const ;



            virtual bool existsAsSymbolicLink( 
                const std::string & linkName ) const ;



            virtual void removeFile( const std::string & filename ) ;



            virtual void moveFile( const std::string & sourceFilename,
                const std::string & targetFilename ) ;



            virtual void copyFile( const std::string & sourceFilename,
                const std::string & targetFilename ) ;



            virtual Ceylan::System::Size 
                getSize( const std::string & filename ) ;



            virtual time_t getLastChangeTimeFile( 
                const std::string & filename ) ;



            // transformIntoValidFilename inherited from File.



            virtual void touch( const std::string & filename ) ;



            // diff directly inherited from File.



            virtual void allowSymbolicFiles( bool newStatus ) ;
             


        
            // Directory-related section.
        
        

            // Factory-related subsection.

            
            
            virtual Ceylan::System::Directory & createDirectory( 
                const std::string & newDirectoryName ) ;


            
            virtual Ceylan::System::Directory & openDirectory( 
                const std::string & directoryName = "" ) ;
                


            virtual bool existsAsDirectory( 
                const std::string & directoryPath ) const ;



            virtual void removeDirectory( const std::string & directoryPath, 
                bool recursive = false ) ;



            virtual void moveDirectory( 
                const std::string & sourceDirectoryPath,
                const std::string & targetDirectoryPath ) ;



            virtual void copyDirectory( 
                const std::string & sourceDirectoryPath,
                const std::string & targetDirectoryPath ) ;



            virtual time_t getLastChangeTimeDirectory( 
                const std::string & directoryPath ) ;
                
                
                
            virtual bool isAValidDirectoryPath( 
                const std::string & directoryString ) ;
        
        
        
            // removeLeadingSeparator inherited.
        
        
        
            virtual bool isAbsolutePath( const std::string & path ) ;
        
        
        
            virtual std::string getCurrentWorkingDirectoryPath() ;



            virtual void changeWorkingDirectory( 
                const std::string & newWorkingDirectory ) ;



            /*
             * Already available from FileSystemManager:
             *   - splitPath
             *   - joinPath (both)
             *   - stripFilename
             *
             */



            // EmbeddedFileSystemManager own section.
            


            static std::string GetBackendLastError() ;



            static Ceylan::Byte GetXORByte() ;
            
            
            
            virtual const std::string toString( 
                Ceylan::VerbosityLevels level = Ceylan::high ) const ;
    





            // Static section to handle embedded filesystem manager.
        


            static EmbeddedFileSystemManager & 
                GetEmbeddedFileSystemManager( bool cypher = true ) ;



            static bool SecureEmbeddedFileSystemManager() ;



            static void RemoveEmbeddedFileSystemManager() ;
        
        
        
            explicit EmbeddedFileSystemManager( bool cypher = true ) ;



            virtual ~EmbeddedFileSystemManager() throw() ;



            
            // Archive locator section.
            
                
                
            static std::string ArchivePathEnvironmentVariable  ;
                
                
                 
            static Ceylan::System::FileLocator ArchiveFileLocator ;



            static std::string FindArchivePath( 
                const std::string & archiveFilename ) ;




        private:
            
            
            
            bool _cypher ;
            
            
            
            static const Ceylan::Byte XORByte ;
             
            
            
            
            // Directory constants.
            
            
            
            static const std::string RootDirectoryPrefix ;


            static const Ceylan::Latin1Char Separator ;
            
                    
                    
            EmbeddedFileSystemManager( 
                const EmbeddedFileSystemManager & source ) ;
        
        
            EmbeddedFileSystemManager & operator = ( 
                const EmbeddedFileSystemManager & source ) ;
            
            
                
                
            static EmbeddedFileSystemManager * _EmbeddedFileSystemManager ;
            


    } ;


}



#endif // OSDL_EMBEDDED_FILE_SYSTEM_MANAGER_H_

---