FileMgr Class Reference

#include <filemgr.h>

Inheritance diagram for FileMgr:

Collaboration diagram for FileMgr:

Public Member Functions
void	close (FileDesc *file)
	FileMgr (int maxFiles=35)
virtual void	flush ()
SWBuf	getHomeDir ()
virtual long	lastAccess ()
FileDesc *	open (const char *path, int mode, bool tryDowngrade)
FileDesc *	open (const char *path, unsigned int mode, bool tryDowngrade)
FileDesc *	open (const char *path, unsigned int mode, unsigned int perms=IREAD|IWRITE, bool tryDowngrade=false)
FileDesc *	open (const char *path, int mode, int perms=IREAD|IWRITE, bool tryDowngrade=false)
virtual long	resourceConsumption ()
signed char	trunc (FileDesc *file)
	~FileMgr ()

Static Public Member Functions
static void	closeFile (int fd)
static int	copyDir (const char *srcDir, const char *destDir)
static int	copyFile (const char *srcFile, const char *destFile)
static int	createParent (const char *pName)
static int	createPathAndFile (const char *fName)
static signed char	existsDir (const char *ipath, const char *idirName=0)
static signed char	existsFile (const char *ipath, const char *ifileName=0)
static std::vector< struct DirEntry >	getDirList (const char *dirPath, bool includeSize=false, bool includeIsDirectory=true)
static SWBuf	getEnvValue (const char *variableName)
static long	getFileSize (const char *path)
static char	getLine (FileDesc *fDesc, SWBuf &line)
static FileMgr *	getSystemFileMgr ()
static bool	hasAccess (const char *path, int mode)
static char	isDirectory (const char *path)
static int	openFile (const char *fName, int mode, int perms)
static int	openFileReadOnly (const char *fName)
static int	removeDir (const char *targetDir)
static int	removeFile (const char *fName)
static void	setSystemFileMgr (FileMgr *newFileMgr)
static long	write (int fd, const void *buf, long count)

Public Attributes
int	maxFiles

Static Public Attributes
static unsigned int	APPEND = O_APPEND
static unsigned int	CREAT = O_CREAT
static unsigned int	IREAD = S_IREAD
static unsigned int	IWRITE = S_IWRITE
static unsigned int	RDONLY = O_RDONLY
static unsigned int	RDWR = O_RDWR
static unsigned int	TRUNC = O_TRUNC
static unsigned int	WRONLY = O_WRONLY

Static Protected Attributes
static FileMgr *	systemFileMgr = 0

Private Member Functions
int	sysOpen (FileDesc *file)

Private Attributes
FileDesc *	files

Friends
class	__staticsystemFileMgr
class	FileDesc

Detailed Description

This class isolates all file io for SWORD, making OS level quirks easier to fix. This class is typically copied and replaced if necessary to get SWORD to run on a specific platform (e.g., Windows Mobile), but in the future, statics should be removed to make possible to instead simply subclass and override necessary methods.

This class also provides many convenience methods which make working with data storage easier.

Conceptually, this factory exposes an interface which allows SWORD to 'open' every file it wants, without worrying about OS limits, and takes care of opening and closing the actual file descriptors when necessary.

Definition at line 62 of file filemgr.h.

Constructor & Destructor Documentation

FileMgr::FileMgr

(

int

maxFiles = 35

)

Constructor.

Parameters

maxFiles

The number of files that this FileMgr may open in parallel, if necessary.

Definition at line 158 of file filemgr.cpp.

                             {
    this->maxFiles = maxFiles;      // must be at least 2
    files = 0;
}

FileMgr::~FileMgr

(

)

Destructor. Clean things up. Will close all files opened by this FileMgr object.

Definition at line 164 of file filemgr.cpp.

                  {
    FileDesc *tmp;

    while(files) {
        tmp = files->next;
        delete files;
        files = tmp;
    }
}

Member Function Documentation

void FileMgr::close

(

FileDesc *

file

)

Close a given file and delete its FileDesc object. Will only close the file if it was created by this FileMgr object.

Parameters

file	The file to close.

Definition at line 196 of file filemgr.cpp.

                                  {
    FileDesc **loop;

    for (loop = &files; *loop; loop = &((*loop)->next)) {
        if (*loop == file) {
            *loop = (*loop)->next;
            delete file;
            break;
        }
    }
}

void FileMgr::closeFile ( int  fd )

static

Definition at line 491 of file filemgr.cpp.

                              {
    ::close(fd);
}

int FileMgr::copyDir ( const char *  srcDir, const char *  destDir  )

static

Definition at line 618 of file filemgr.cpp.

                                                            {
    SWBuf baseSrcPath = srcDir;
    if (!baseSrcPath.endsWith("/") && !baseSrcPath.endsWith("\\")) baseSrcPath += "/";
    SWBuf baseDestPath = destDir;
    if (!baseDestPath.endsWith("/") && !baseDestPath.endsWith("\\")) baseDestPath += "/";
    int retVal = 0;
    std::vector<DirEntry> dirList = getDirList(srcDir);
    for (unsigned int i = 0; i < dirList.size() && !retVal; ++i) {
        SWBuf srcPath  = baseSrcPath  + dirList[i].name;
        SWBuf destPath = baseDestPath + dirList[i].name;
        if (!dirList[i].isDirectory) {
            retVal = copyFile(srcPath.c_str(), destPath.c_str());
        }
        else {
            retVal = copyDir(srcPath.c_str(), destPath.c_str());
        }
    }
    return retVal;
}

int FileMgr::copyFile ( const char *  srcFile, const char *  destFile  )

static

Definition at line 496 of file filemgr.cpp.

                                                                    {
    int sfd, dfd, len;
    char buf[4096];

    if ((sfd = openFile(sourceFile, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH)) < 1)
        return -1;
    if ((dfd = createPathAndFile(targetFile)) < 1)
        return -1;

    do {
        len = (int)read(sfd, buf, 4096);
        if (write(dfd, buf, len) != len) break;
    }
    while(len == 4096);
    ::close(dfd);
    ::close(sfd);

    return 0;
}

int FileMgr::createParent ( const char *  pName )

static

Definition at line 426 of file filemgr.cpp.

                                           {
    char *buf = new char [ strlen(pName) + 1 ];
    int retCode = 0;

    strcpy(buf, pName);
    int end = (int)strlen(buf) - 1;
    while (end) {
        if ((buf[end] == '/') || (buf[end] == '\\'))
            break;
        end--;
    }
    buf[end] = 0;
    if (strlen(buf)>0) {
        if (!hasAccess(buf, 02)) {  // not exists with write access?
            retCode =
#ifndef WIN32
                mkdir(buf, 0755);
#else
                _wmkdir((const wchar_t *)utf8ToWChar(buf).getRawData());
#endif
            if (retCode) {
                createParent(buf);
                retCode =
#ifndef WIN32
                    mkdir(buf, 0755);
#else
                    _wmkdir((const wchar_t *)utf8ToWChar(buf).getRawData());
#endif
            }
        }
    }
    else retCode = -1;
    delete [] buf;
    return retCode;
}

int FileMgr::createPathAndFile ( const char *  fName )

static

Definition at line 479 of file filemgr.cpp.

                                                {
    int fd;

    fd = openFile(fName, O_CREAT|O_WRONLY|O_BINARY, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH);
    if (fd < 1) {
        createParent(fName);
        fd = openFile(fName, O_CREAT|O_WRONLY|O_BINARY, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH);
    }
    return fd;
}

signed char FileMgr::existsDir ( const char *  ipath, const char *  idirName = 0  )

static

Checks for the existence and readability of a directory.

Parameters

ipath	Path to directory.
idirName	Name of directory to check for.

Definition at line 357 of file filemgr.cpp.

{
    char *ch;
    int len = (int)strlen(ipath) + ((idirName)?strlen(idirName):0) + 1;
    if (idirName)
        len +=  strlen(idirName);
    char *path = new char [ len ];
    strcpy(path, ipath);

    if ((path[strlen(path)-1] == '\\') || (path[strlen(path)-1] == '/'))
        path[strlen(path)-1] = 0;

    if (idirName) {
        ch = path + strlen(path);
        sprintf(ch, "/%s", idirName);
    }
    signed char retVal = hasAccess(path, 04) ? 1 : 0;
    delete [] path;
    return retVal;
}

signed char FileMgr::existsFile ( const char *  ipath, const char *  ifileName = 0  )

static

Checks for the existence and readability of a file.

Parameters

ipath	Path to file.
ifileName	Name of file to check for.

Definition at line 337 of file filemgr.cpp.

{
    int len = (int)strlen(ipath) + ((ifileName)?strlen(ifileName):0) + 3;
    char *ch;
    char *path = new char [ len ];
    strcpy(path, ipath);

    if ((path[strlen(path)-1] == '\\') || (path[strlen(path)-1] == '/'))
        path[strlen(path)-1] = 0;

    if (ifileName) {
        ch = path + strlen(path);
        sprintf(ch, "/%s", ifileName);
    }
    signed char retVal = hasAccess(path, 04) ? 1 : 0;
    delete [] path;
    return retVal;
}

void FileMgr::flush ( )

virtual

Cacher methods overridden

Reimplemented from SWCacher.

Definition at line 657 of file filemgr.cpp.

                    {
    FileDesc **loop;

    for (loop = &files; *loop; loop = &((*loop)->next)) {
        if ((*loop)->fd > 0) {
            (*loop)->offset = lseek((*loop)->fd, 0, SEEK_CUR);
            ::close((*loop)->fd);
            (*loop)->fd = -77;
        }
    }
}

std::vector< struct DirEntry > FileMgr::getDirList ( const char *  dirPath, bool  includeSize = false, bool  includeIsDirectory = true  )

static

Given a directory path, returns contents of directory

Parameters

dirPath	Path to directory
includeSize	Optimization flag to allow passing false to skip file size lookup (true forces both size and directory lookup)
includeIsDirectory	Optimization flag to allow passing false to skip isDirectory lookup

Returns

a container of DirEntry records describing contents

Definition at line 379 of file filemgr.cpp.

                                                                                                             {
    std::vector<struct DirEntry> dirList;
    SWBuf basePath = dirPath;
    if (!basePath.endsWith("/") && !basePath.endsWith("\\")) basePath += "/";

#ifndef WIN32
    DIR *dir;
    struct dirent *ent;
    if ((dir = opendir(dirPath))) {
        rewinddir(dir);
        while ((ent = readdir(dir))) {
            if ((strcmp(ent->d_name, ".")) && (strcmp(ent->d_name, ".."))) {
                struct DirEntry i;
                i.name = ent->d_name;
                if (includeIsDirectory || includeSize) i.isDirectory = FileMgr::isDirectory(basePath + ent->d_name);
                if (!i.isDirectory && includeSize) i.size = FileMgr::getFileSize(basePath + ent->d_name);
                dirList.push_back(i);
            }
        }
        closedir(dir);
    }

#else
    // Crappy Windows-specific code because well... They can't be conformant
    WIN32_FIND_DATAW fileData;
    SWBuf wcharBuf = utf8ToWChar(basePath+"*");
    const wchar_t *wcharPath = (const wchar_t *)wcharBuf.getRawData();
    HANDLE findIterator = FindFirstFileW(wcharPath, &fileData);
    if (findIterator != INVALID_HANDLE_VALUE) {
        do {
            SWBuf dirEntName = wcharToUTF8(fileData.cFileName);
            if (dirEntName != "." && dirEntName != "..") {
                struct DirEntry i;
                i.name = dirEntName;
                i.isDirectory = fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
                if (!i.isDirectory && includeSize) i.size = FileMgr::getFileSize(basePath + i.name);
                dirList.push_back(i);
            }
        } while (FindNextFileW(findIterator, &fileData) != 0);
        FindClose(findIterator);
    }
#endif

    return dirList;
}

SWBuf FileMgr::getEnvValue ( const char *  variableName )

static

Get an environment variable from the OS

Parameters

variableName

the name of the env variable to retrieve

Returns

variable value from the OS

Definition at line 316 of file filemgr.cpp.

                                                   {
    return
#ifdef WIN32
        wcharToUTF8(_wgetenv((const wchar_t *)utf8ToWChar(variableName).getRawData()));
#else
        getenv(variableName);
#endif

}

long FileMgr::getFileSize ( const char *  path )

static

Definition at line 605 of file filemgr.cpp.

                                          {
#ifndef WIN32
    struct stat stats;
    int error = stat(path, &stats);
#else
    struct _stat stats;
    int error = _wstat((const wchar_t *)utf8ToWChar(path).getRawData(), &stats);
#endif
    if (error) return 0;
    return stats.st_size;
}

SWBuf FileMgr::getHomeDir

(

)

Determines where SWORD looks for the user's home folder. This is typically used as a place to find any additional personal SWORD modules which a user might wish to be added to a system-wide library (e.g., added from ~/.sword/mods.d/ or ~/sword/mods.d/)

or if a user or UI wishes to override SWORD system configuration settings (e.g., /etc/sword.conf) with a custom configuration (e.g., ~/.sword/sword.conf)

Definition at line 681 of file filemgr.cpp.

                          {

    // figure out 'home' directory for app data
    SWBuf homeDir = getEnvValue("HOME");
    if (!homeDir.length()) {
        // silly windows
        homeDir = getEnvValue("APPDATA");
    }
    if (homeDir.length()) {
        if ((homeDir[homeDir.length()-1] != '\\') && (homeDir[homeDir.length()-1] != '/')) {
            homeDir += "/";
        }
    }

    return homeDir;
}

char FileMgr::getLine ( FileDesc *  fDesc, SWBuf &  line  )

static

Definition at line 527 of file filemgr.cpp.

                                                  {
    int len = 0;
    bool more = true;
    char chunk[255];

    line = "";

    // assert we have a valid file handle
    if (fDesc->getFd() < 1)
        return 0;

    while (more) {
        more = false;
        long index = fDesc->seek(0, SEEK_CUR);
        len = (int)fDesc->read(chunk, 254);

        // assert we have a readable file (not a directory)
        if (len < 1)
            break;

        int start = 0;
        // clean up any preceding white space if we're at the beginning of line
        if (!line.length()) {
            for (;start < len; start++) {
                if ((chunk[start] != 13) && (chunk[start] != ' ') && (chunk[start] != '\t'))
                    break;
            }
        }

        // find the end
        int end;
        for (end = start; ((end < (len-1)) && (chunk[end] != 10)); end++);

        if ((chunk[end] != 10) && (len == 254)) {
            more = true;
        }
        index += (end + 1);

        // reposition to next valid place to read
        fDesc->seek(index, SEEK_SET);

        // clean up any trailing junk on line if we're at the end
        if (!more) {
            for (; end > start; end--) {
                if ((chunk[end] != 10) && (chunk[end] != 13) && (chunk[end] != ' ') && (chunk[end] != '\t')) {
                    if (chunk[end] == '\\') {
                        more = true;
                        end--;
                    }
                    break;
                }
            }
        }

        int size = (end - start) + 1;

        if (size > 0) {
            // line.appendFormatted("%.*s", size, chunk+start);
            line.append(chunk+start, size);
        }
    }
    return ((len > 0) || line.length());
}

FileMgr * FileMgr::getSystemFileMgr ( )

static

Definition at line 101 of file filemgr.cpp.

                                   {
    if (!systemFileMgr)
        systemFileMgr = new FileMgr();

    return systemFileMgr;
}

bool FileMgr::hasAccess ( const char *  path, int  mode  )

static

Check if a path can be access with supplied permissions

Parameters

path	Path to the resource
mode	Desired access mode

Returns

whether or not the resource can be accessed with the requested mode

Definition at line 327 of file filemgr.cpp.

                                                  {
    return
#ifdef WIN32
        !_waccess((const wchar_t *)utf8ToWChar(path).getRawData(), mode);
#else
        !access(path, mode);
#endif
}

char FileMgr::isDirectory ( const char *  path )

static

Definition at line 592 of file filemgr.cpp.

                                          {
#ifndef WIN32
    struct stat stats;
    int error = stat(path, &stats);
#else
    struct _stat stats;
    int error = _wstat((const wchar_t *)utf8ToWChar(path).getRawData(), &stats);
#endif
    if (error) return 0;
    return ((stats.st_mode & S_IFDIR) == S_IFDIR);
}

long SWCacher::lastAccess ( )

virtualinherited

Definition at line 46 of file swcacher.cpp.

                          {
    return 0;
}

FileDesc * FileMgr::open	(	const char *	path,
		int	mode,
		bool	tryDowngrade
	)

Open a file and return a FileDesc for it. The file itself will only be opened when FileDesc::getFd() is called.

Parameters

path	Filename.
mode	File access mode.
tryDowngrade	if we can't open the file for permissions requested, try to open the file with less permissions

Returns

FileDesc object for the requested file.

Definition at line 175 of file filemgr.cpp.

                                                                     {
    return open(path, mode, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH, tryDowngrade);
}

FileDesc* FileMgr::open ( const char *  path, unsigned int  mode, bool  tryDowngrade  )

inline

Definition at line 108 of file filemgr.h.

{ return this->open(path, (int)mode, tryDowngrade); }

FileDesc* FileMgr::open ( const char *  path, unsigned int  mode, unsigned int  perms = IREAD | IWRITE, bool  tryDowngrade = false  )

inline

Open a file and return a FileDesc for it. The file itself will only be opened when FileDesc::getFd() is called.

Parameters

path	Filename.
mode	File access mode.
perms	Permissions.
tryDowngrade

Returns

FileDesc object for the requested file.

Definition at line 118 of file filemgr.h.

{ return this->open(path, (int)mode, (int)perms, tryDowngrade); }

FileDesc * FileMgr::open	(	const char *	path,
		int	mode,
		int	perms = IREAD | IWRITE,
		bool	tryDowngrade = false
	)

Definition at line 180 of file filemgr.cpp.

                                                                                {
    FileDesc **tmp, *tmp2;

    for (tmp = &files; *tmp; tmp = &((*tmp)->next)) {
        if ((*tmp)->fd < 0)     // insert as first non-system_open file
            break;
    }

    tmp2 = new FileDesc(this, path, mode, perms, tryDowngrade);
    tmp2->next = *tmp;
    *tmp = tmp2;

    return tmp2;
}

int FileMgr::openFile ( const char *  fName, int  mode, int  perms  )

static

attempts to open a file readonly

Parameters

fName

filename to open

Returns

fd; < 0 = error

Definition at line 463 of file filemgr.cpp.

                                                            {
    int fd =
#ifndef WIN32
        ::open(fName, mode, perms);
#else
        ::_wopen((const wchar_t *)utf8ToWChar(fName).getRawData(), mode, perms);
#endif
    return fd;
}

int FileMgr::openFileReadOnly ( const char *  fName )

static

Definition at line 474 of file filemgr.cpp.

                                               {
    return openFile(fName, O_RDONLY|O_BINARY, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH);
}

int FileMgr::removeDir ( const char *  targetDir )

static

Definition at line 639 of file filemgr.cpp.

                                            {
    SWBuf basePath = targetDir;
    if (!basePath.endsWith("/") && !basePath.endsWith("\\")) basePath += "/";
    std::vector<DirEntry> dirList = getDirList(targetDir);
    for (unsigned int i = 0; i < dirList.size(); ++i) {
        SWBuf targetPath = basePath + dirList[i].name;
        if (!dirList[i].isDirectory) {
            FileMgr::removeFile(targetPath.c_str());
        }
        else {
            FileMgr::removeDir(targetPath.c_str());
        }
    }
    FileMgr::removeFile(targetDir);
    return 0;
}

int FileMgr::removeFile ( const char *  fName )

static

Definition at line 517 of file filemgr.cpp.

                                         {
    return
#ifndef WIN32
    ::remove(fName);
#else
    ::_wremove((const wchar_t *)utf8ToWChar(fName).getRawData());
#endif
}

long FileMgr::resourceConsumption ( )

virtual

Reimplemented from SWCacher.

Definition at line 669 of file filemgr.cpp.

                                  {
    long count = 0;
    FileDesc **loop;
    for (loop = &files; *loop; loop = &((*loop)->next)) {
        if ((*loop)->fd > 0) {
            count++;
        }
    }
    return count;
}

void FileMgr::setSystemFileMgr ( FileMgr *  newFileMgr )

static

Definition at line 109 of file filemgr.cpp.

                                                  {
    if (systemFileMgr)
        delete systemFileMgr;
    systemFileMgr = newFileMgr;
}

int FileMgr::sysOpen ( FileDesc *  file )

private

Definition at line 209 of file filemgr.cpp.

                                   {
    FileDesc **loop;
    int openCount = 1;      // because we are presently opening 1 file, and we need to be sure to close files to accomodate, if necessary

    for (loop = &files; *loop; loop = &((*loop)->next)) {

        if ((*loop)->fd > 0) {
            if (++openCount > maxFiles) {
                (*loop)->offset = lseek((*loop)->fd, 0, SEEK_CUR);
                ::close((*loop)->fd);
                (*loop)->fd = -77;
            }
        }

        if (*loop == file) {
            if (*loop != files) {
                *loop = (*loop)->next;
                file->next = files;
                files = file;
            }
            if ((hasAccess(file->path, 04)) || ((file->mode & O_CREAT) == O_CREAT)) {   // check for at least file exists / read access before we try to open
                char tries = (((file->mode & O_RDWR) == O_RDWR) && (file->tryDowngrade)) ? 2 : 1;  // try read/write if possible
                for (int i = 0; i < tries; i++) {
                    if (i > 0) {
                        file->mode = (file->mode & ~O_RDWR);    // remove write access
                        file->mode = (file->mode | O_RDONLY);// add read access
                    }
                    file->fd = openFile(file->path, file->mode|O_BINARY, file->perms);
                    if (file->fd >= 0)
                        break;
                }

                if (file->fd >= 0)
                    lseek(file->fd, file->offset, SEEK_SET);
            }
            else file->fd = -1;
            if (!*loop)
                break;
        }
    }
    return file->fd;
}

signed char FileMgr::trunc

(

FileDesc *

file

)

Truncate a file at its current position leaving byte at current possition intact deleting everything afterward.

Parameters

file	The file to operate on.

Definition at line 256 of file filemgr.cpp.

                                         {

    static const char *writeTest = "x";
    long size = file->seek(1, SEEK_CUR);
    if (size == 1) // was empty
        size = 0;
    char nibble [ 32767 ];
    bool writable = file->write(writeTest, 1);
    int bytes = 0;

    if (writable) {
        // get tmpfilename
        char *buf = new char [ strlen(file->path) + 10 ];
        int i;
        for (i = 0; i < 9999; i++) {
            sprintf(buf, "%stmp%.4d", file->path, i);
            if (!existsFile(buf))
                break;
        }
        if (i == 9999)
            return -2;

        FileDesc *fd = open(buf, CREAT|RDWR);
        if (!fd || fd->getFd() < 0)
            return -3;

        file->seek(0, SEEK_SET);
        while (size > 0) {
            bytes = (int)file->read(nibble, 32767);
            bytes = (bytes < size)?bytes:(int)size;
            if (fd->write(nibble, bytes) != bytes) { break; }
            size -= bytes;
        }
        if (size < 1) {
            // zero out the file
            ::close(file->fd);
            file->fd = openFile(file->path, O_TRUNC, S_IREAD|S_IWRITE|S_IRGRP|S_IROTH);
            ::close(file->fd);
            file->fd = -77; // force file open by filemgr
            // copy tmp file back (dumb, but must preserve file permissions)
            fd->seek(0, SEEK_SET);
            do {
                bytes = fd->read(nibble, 32767);
                file->write(nibble, bytes);
            } while (bytes == 32767);
        }

        close(fd);
        ::close(file->fd);
        removeFile(buf);        // remove our tmp file
        file->fd = -77; // causes file to be swapped out forcing open on next call to getFd()
    }
    else { // put offset back and return failure
        file->seek(-1, SEEK_CUR);
        return -1;
    }
    return 0;
}

long FileMgr::write ( int  fd, const void *  buf, long  count  )

static

Definition at line 115 of file filemgr.cpp.

                                                       {
    return ::write(fd, buf, count);
}

Friends And Related Function Documentation

friend class __staticsystemFileMgr

friend

Definition at line 65 of file filemgr.h.

friend class FileDesc

friend

Definition at line 64 of file filemgr.h.

Member Data Documentation

unsigned int FileMgr::APPEND = O_APPEND

static

Definition at line 73 of file filemgr.h.

SWORD_NAMESPACE_START unsigned int FileMgr::CREAT = O_CREAT

static

Definition at line 72 of file filemgr.h.

FileDesc* FileMgr::files

private

Definition at line 67 of file filemgr.h.

unsigned int FileMgr::IREAD = S_IREAD

static

Definition at line 78 of file filemgr.h.

unsigned int FileMgr::IWRITE = S_IWRITE

static

Definition at line 79 of file filemgr.h.

int FileMgr::maxFiles

Maximum number of open files set in the constructor. determines the max number of real system files that filemgr will open. Adjust for tuning.

Definition at line 85 of file filemgr.h.

unsigned int FileMgr::RDONLY = O_RDONLY

static

Definition at line 75 of file filemgr.h.

unsigned int FileMgr::RDWR = O_RDWR

static

Definition at line 76 of file filemgr.h.

FileMgr * FileMgr::systemFileMgr = 0

staticprotected

Definition at line 70 of file filemgr.h.

unsigned int FileMgr::TRUNC = O_TRUNC

static

Definition at line 74 of file filemgr.h.

unsigned int FileMgr::WRONLY = O_WRONLY

static

Definition at line 77 of file filemgr.h.

---

The documentation for this class was generated from the following files:

• include/filemgr.h
• src/mgr/filemgr.cpp