source: nrEngine/include/IFileSystem.h @ 1

Revision 1, 5.7 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14#ifndef _NR_I_FILESYSTEM_H_
15#define _NR_I_FILESYSTEM_H_
16
17
18//----------------------------------------------------------------------------------
19// Includes
20//----------------------------------------------------------------------------------
21#include "Prerequisities.h"
22#include "Property.h"
23#include "FileStream.h"
24
25namespace nrEngine{
26
27        //! File system module interface that are managed by file system manager
28        /**
29         * Each file system has it's own handling routines and access controls.
30         * So this class provide an interface for abstract using of such file systems.
31         * Modules derived from this interface can be registered by the file system manager
32         * so they are used to access files.
33         *
34         * Each file system does have a type. A type is unique for each kind of fs.
35         * The name of the type is used to allow user to specify directly the fs he
36         * want to use to access the files. So calling "file:/.." force a local file
37         * system to be used and "http:/..." will access the files through htpp-interface.
38         * Accessing the files without any fs specified force the manager to look
39         * for the file under each registered file system.
40         *
41         * User can also specify parameters to the file system by accessing the files.
42         * The parameters are separated through ':' and are given in the file name.
43         * You can also specify parameters by setting them directly. The parameters
44         * are always states. i.e. if parameter 1 is set to the value A, so this
45         * value will be used until it is changed. Parameters specified in the filename
46         * are local parameters used only for the current access and they overload
47         * the global parameters of the file system.
48         *
49         * \ingroup vfs
50        **/
51        class _NRExport IFileSystem{
52                public:
53       
54                        //! Initalize the file system
55                        IFileSystem();
56       
57                        //! Release used memory and force all files to close
58                        virtual ~IFileSystem();
59
60                        /**
61                         * Each file has more info about it than only a name.
62                         * So we store file info in a structure.
63                         **/
64                        struct FileInfo{
65                                //! The file system to which one this file belongs
66                                IFileSystem* fsParent;
67
68                                //! full name of the file
69                                std::string name;
70
71                                //! virtual path of the file separated by '/' and ending with '/'
72                                std::string path;
73
74                                //! real file path, in the file system specific manner
75                                std::string realPath;
76                               
77                                //! size of the file
78                                size_t size;
79                               
80                        };
81                       
82                        //! Vector containing file info information
83                        typedef std::vector<FileInfo> FileInfoList;
84                        typedef SharedPtr<FileInfoList> FileInfoListPtr;
85
86                       
87                        /**
88                         * Check whenever such a file exists in that file system.
89                         * @param fileName
90                         **/
91                        virtual bool exists(const std::string& fileName) = 0;
92
93                        /**
94                         * Returns true if this filesystem is case sensitive by matching the filenames
95                         **/
96                        virtual bool isCaseSensitive() const = 0;
97
98                        /**
99                         * List all files in the archive. You get the file info list containing
100                         * information about each file in the archive
101                         *
102                         * @param recursive if true so search for the files recursively
103                         **/
104                        virtual FileInfoListPtr listFiles(bool recursive = true) = 0;
105                       
106                        /**
107                         * Find a file by the given pattern. Wildcard '*' is allowed.
108                         *
109                         * @param pattern filename pattern including wildcards
110                         * @param recursive if true so search recursively
111                         **/
112                        virtual FileInfoListPtr findFiles(const std::string& pattern, bool recursive = true) = 0;
113
114                        /**
115                         * Initialize the file system.
116                         **/
117                        virtual Result initialize() = 0;
118
119                        /**
120                         * Release the file system and close all opened files.
121                         **/
122                        virtual Result deinitialize() = 0;
123
124                        /**
125                         * Open a file by the given filename. The method returns a smart pointer
126                         * on the file stream. So as soon as the pointer is not used anymore the file will
127                         * be closed automaticaly behaving to the file stream.
128                         *
129                         * @param filename Name of the file (without parameters)
130                         * @param params Local parameters for this access
131                         **/
132                        virtual SharedPtr<FileStream> open(const std::string& filename, PropertyList* = NULL) = 0;
133
134                        /**
135                         * File system type. This type is used to allow users to access directly
136                         * to the files on this filesystem.
137                         **/
138                        virtual const std::string& getType() { return mType; }
139
140                        /**
141                         * Set global parameters for this file system
142                         * @param param Parameter number
143                         * @param value Value of the parameter
144                         **/
145                        virtual Result set(uint32 param, const std::string& value);
146
147                        /**
148                         * This method allows to setup the parameters by their names.
149                         * The file system modules should specifiy somehow the parameter
150                         * names which can be used to setup them
151                         *
152                         * @param name Name of the paramter (i.e. by ftp access "username")
153                         * @param value Value of the parameter
154                         **/
155                        virtual Result set(const std::string& name, const std::string& value);
156                       
157                protected:
158
159                        //! Unique type name for this file system
160                        std::string mType;
161
162                        //! Map containing the parameters and their values
163                        PropertyList    mParameter;
164
165        };
166
167};
168
169#endif
Note: See TracBrowser for help on using the repository browser.