The FileSystem Service Class
The service class
FileSystem interacts with the operating system to form, decompose, and determine file names and attributes so that they conform the requirements of the hosting platform. In addition, it performs several low level file management operations such as searching for files and loading text files into internal text streams.
A full filename is viewed as consisting of three components:
Component | Description |
pathname | Contains the location within the file system of the file. If it is omitted the the currently selected location is assumed. |
localname | contains the actual name of the file. This is the only component that cannot be omitted. |
extension | contains a short extension that describes the type of the file. If it is omitted then the context is often used to determine its value. |
The method FileSystem_FileName
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_FileName(char* fileIdent,int nIdent,char* name,int iExt);
|
The
FileSystem_FileName method extracts the local name from a full filename. In particular it locates the local name and copies it into the return parameter as a null-terminated string. If the include extension flag is nonzero, then the extension is included with the name. Its parameters are as follows:
Parameter | Description |
fileIdent | Contains the file name to be parsed. It need be null-terminated only if its length is not specified. |
nIdent | Specifies the length of file name. If it is set to zero, then the length is computed. |
name | Receives the localname of the file possibly concatenated with its extension. It is null-terminated. |
iExt | Specifies whether the extension should be included in the returned name. If it is nonzero, then the extension is included in the name. |
This method returns the overall length of the local name.
The method FileSystem_FindFiles
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
void* FileSystem_FindFiles(char* directory,char* extensions);
|
The
FileSystem_FindFiles method searches the directory tree starting in a specified directory for all files that have some specified number of extensions. The full names of the local files are stored in a text stream whose handle is the return value of this method. Its parameters are as follows:
Parameter | Description |
directory | Contains the full name of the root directory for the search. |
extensions | Contains a comma-delimited string of the extensions to be searched for. |
The method returns the handle of the local text stream which contains the full filenames. It can be NULL, if it could not be created. It can contain no entries, if no files were found or if the starting directory did not exist.
The method FileSystem_GetDirectory
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_GetDirectory(char* buffer,char* string,int nString,int remove);
|
The
FileSystem_GetDirectory method gets the full directory name from a path name by removing the local filename. In addition, it may remove additional subdirectory names. Its parameters are as follows:
Parameter | Description |
buffer | Receives the directory name extracted from the pathname in null-terminated form. |
string | Contains the full pathname of a file whose directory location is wanted. It need be null-terminated only if nString set to zero. |
nString | Specifies the overall length of the pathname. If set to zero, then the length of the pathname is computed. |
removed | Specifies the number of subdirectory names to be removed from the back of the directory name. |
This method returns the length in characters of the returned directory name.
The method FileSystem_LoadFile
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_LoadFile(void* Storage,char* filename,int strip);
|
The
FileSystem_LoadFile method loads the content of a text file into a text stream in storage. Optionally, leading and/or trailing whitespace is stripped. The file is closed after it has been read. Note that both ASCII and Unicode files can be read by this method. The Unicode is transparently converted to ASCII before loading the records into the text stream. Its parameters are as follows:
Parameter | Description |
Storage | Specifies the handle for the storage area to contain the text buffer. If this handle is NULL, then the text buffer will be allocated to a memory based storage area. If the LoadFile_UseExisting entry flag is set then this parameter Specifies the handle of the text stream. |
filename | Contains the full filename for the text file whose content is to be loaded. |
strip | Specifies how records are to be modified and/or stored in the text stream. The bits this parameter are used as follows: Entry | Description of use | LoadFile_StripTrailing | strip trailing whitespace | LoadFile_StripLeading | strip leading white space | LoadFile_ReplaceCR | replace embedded CR's with newlines | LoadFile_NullTerminate | terminate stored records with null-byte | LoadFile_UseExisting | insert file into existing text stream |
|
The method returns the root offset of the variable information stream that contains the records of the file if all goes well. If the file cannot be opened with readonly access, then a zero is returned.
The method FileSystem_MakeFullName
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_MakeFullName(char* path,char* name,int nname,char* ext,char* fullname);
|
The
FileSystem_MakeFullName method forms a full filename from its components. This method views a file as though it consisted of three concatenated components: path name, local name, and extension. This method constructs the full name in accordance with the conventions of the platform. It has the following parameters:
Parameter | Description |
path | Contains the path name to be used. It may be NULL, in which case a local filename is constructed. |
name | Contains the local name of the file. It need not be null-terminated if the nname parameter is not zero. |
nname | Specifies the number of characters in the beginning of the name parameter. If it is zero, then the name string must be null-terminated and its entire content is used. |
ext | Contains the extension to be used. If it is NULL then the filename contains no extension. |
fullname | Receives the full constructed name of the file in null-terminated form. If is up to the user to ensure that it contains sufficient space. |
The method returns the overall length of the filename as constructed.
The method FileSystem_MakeLocalName
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_MakeLocalName(char* FileName,char* LocalName,int LocalLength,CONST char* Extension,int XtnLength);
|
The
FileSystem_MakeLocalName method creates a local filename by concatenating a local name with the local extension character and an extension. Note that the local name may already contain an extension. In that case that extension is replaced. Its parameters are:
Parameter | Description |
FileName | Receives the constructed local filename in null-terminated form. |
LocalName | Contains the local name to be used. This name may already have an extension at its back. This method does not check the front of this name therefore, it may contain a path name as well. |
LocalLength | specifies length of local name. A value of zero means that LocalName is null-terminated and its length is computed. |
Extension | Contains the extension. |
XtnLength | Specifies the length of the extension. If it is zero then Extension is assumed to be null-terminated. |
The method returns the length of the constructed filename.
The method FileSystem_ParseFileName
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_ParseFileName(char* FileName,int Length,int* LocalStart,int* XtnStart);
|
The
FileSystem_ParseFileName method parses a filename into its components. It views a filename as though it consisted of three concatenated components: path name, local name, and extension. This method computes the relative position within the full name of the start of the local name and the start of the extension. Since the path name is always first, if the local name start is greater than zero, then the beginning of the filename contains a path name. Its parameters are as follows:
Parameter | Description |
FileName | Contains the filename to be parsed. It need be null-terminated only if Length set to zero. |
Length | Specifies the overall length of the filename. If set to zero, then the length of the filename is computed. |
LocalStart | returns the offset of the start of the local name in the filename. A value of zero indicates that the name contains no path name component. |
XtnStart | returns the offset of the start of the extension in the filename. A value of Length indicates that the name had no extension. |
The method returns the overall length of the filename.
The method FileSystem_RelativePathName
Prototype Code Block |
---|
language | cpp |
---|
theme | Eclipse |
---|
linenumbers | true |
---|
|
int FileSystem_RelativePathName(char* parent,char* child,char* relative);
|
The
FileSystem_RelativePathName method creates a relative pathname of a child file as referenced by a parent file, such as a code file being referenced by a project file. Its parameters are as follows:
Parameter | Description |
parent | Contains the full pathname of the parent file. |
child | Contains the full pathname of the child file. |
relative | Receives the relative pathname required to reference the child file when in the parent location. |
The method returns the length of the relative name.