#include <FileSystem.h>

Classes
class	Dir

class	Entry

class	ListSettings

Public Member Functions
void	setCacheLifetime (float t)

Static Public Member Functions
static void	init ()

static void	cleanup ()

static bool	inZipfile (const std::string &path, std::string &zipfile)

static void	clearCache (const std::string &path="")

static FILE *	fopen (const char filename, const char mode)

static void	fclose (FILE *f)

static bool	inZipfile (const std::string &path)

static void	removeFile (const std::string &path)
	Delete this file. No effect if path does not exist. More...

static bool	isZipfile (const std::string &path)

static float	cacheLifetime ()

static void	createDirectory (const std::string &path)

static std::string	currentDirectory ()

static void	copyFile (const std::string &srcPath, const std::string &dstPath)

static bool	exists (const std::string &f, bool trustCache=true, bool caseSensitive=true)

static bool	isDirectory (const std::string &path)

static bool	isFile (const std::string &path)

static std::string	resolve (const std::string &path, const std::string &cwd=currentDirectory())

static bool	isNewer (const std::string &src, const std::string &dst)

static int64	size (const std::string &path)

static void	list (const std::string &spec, Array< std::string > &result, const ListSettings &listSettings=ListSettings())

static void	getFiles (const std::string &spec, Array< std::string > &result, bool includeParentPath=false)

static void	getDirectories (const std::string &spec, Array< std::string > &result, bool includeParentPath=false)

static void	markFileUsed (const std::string &filename)

static const Set< std::string > &	usedFiles ()

Private Types
enum	Type { UNKNOWN, FILE_TYPE, DIR_TYPE }

Private Member Functions
Dir &	getContents (const std::string &path, bool forceUpdate)

	FileSystem ()

bool	_inZipfile (const std::string &path, std::string &zipfile)

void	_clearCache (const std::string &path)

bool	_inZipfile (const std::string &path)

void	_setCacheLifetime (float t)

float	_cacheLifetime () const

void	_createDirectory (const std::string &path)

bool	_exists (const std::string &f, bool trustCache=true, bool caseSensitive=true)

bool	_isDirectory (const std::string &path)

bool	_isFile (const std::string &path)

void	_copyFile (const std::string &srcPath, const std::string &dstPath)

std::string	_resolve (const std::string &path, const std::string &cwd=currentDirectory())

bool	_isNewer (const std::string &src, const std::string &dst)

std::string	_currentDirectory ()

int64	_size (const std::string &path)

void	listHelper (const std::string &shortSpec, const std::string &parentPath, Array< std::string > &result, const ListSettings &settings)

void	_list (const std::string &spec, Array< std::string > &result, const ListSettings &listSettings=ListSettings())

bool	_isZipfile (const std::string &path)

void	_getFiles (const std::string &spec, Array< std::string > &result, bool includeParentPath=false)

void	_getDirectories (const std::string &spec, Array< std::string > &result, bool includeParentPath=false)

FILE *	_fopen (const char filename, const char mode)

void	_removeFile (const std::string &path)
	Delete this file. No effect if path does not exist. More...

Static Private Member Functions
static FileSystem &	instance ()

Private Attributes
Array< std::string >	m_winDrive

float	m_cacheLifetime

Table< std::string, Dir >	m_cache

Static Private Attributes
static GMutex	mutex

Detailed Description

OS-independent file system layer that optimizes the performance of queries by caching and prefetching.

This class uses the following definitions:

"file" = document that can be opened for reading or writing
"directory" = folder containing files and other directories
"node" = file or directory
"path" = string identifying a (see the FSPath class)
"zipfile" = a compressed file storing an archive of files and directories in the zip format

In G3D, Zipfiles are transparently treated as if they were directories, provided:

The zipfile name contains an extension (e.g., map.pk3, files.zip)
There are no nested zipfiles

All FileSystem routines invoke FilePath::expandEnvironmentVariables if the input contains a '$'.

The extension requirement allows G3D to quickly identify whether a path could enter a zipfile without forcing it to open all parent directories for reading.

See also: FilePath

Member Enumeration Documentation

enum G3D::FileSystem::Type

private

Enumerator
UNKNOWN	Not yet checked
FILE_TYPE
DIR_TYPE

  {
  UNKNOWN, 
  FILE_TYPE, 
  DIR_TYPE
  };

Constructor & Destructor Documentation

G3D::FileSystem::FileSystem ( )

private

Don't allow public construction.

69 : m_cacheLifetime(10) {}

G3D::FileSystem::m_cacheLifetime

float m_cacheLifetime

Definition: FileSystem.h:84

Here is the caller graph for this function:

Member Function Documentation

float G3D::FileSystem::_cacheLifetime ( ) const

inlineprivate

A cache is used to optimize repeated calls. A cache entry is considered valid for this many seconds after it has been checked.

  {
  return m_cacheLifetime;
  }

Here is the caller graph for this function:

void G3D::FileSystem::_clearCache ( const std::string & path )

private

Clears old cache entries so that exists() and list() will reflect recent changes to the file system.

Parameters

path	Clear only path and its subdirectories ("" means clear the entire cache)

  {
  const std::string& path = FilePath::expandEnvironmentVariables(_path);
 
  if ((path == "") || FilePath::isRoot(path)) {
  m_cache.clear();
  } else {
  Array<std::string> keys;
  m_cache.getKeys(keys);
 
  const std::string& prefix = 
 # ifdef G3D_WINDOWS
  toLower(FilePath::canonicalize(FilePath::removeTrailingSlash(_resolve(path))));
 # else
  FilePath::canonicalize(FilePath::removeTrailingSlash(_resolve(path)));
 # endif
  const std::string& prefixSlash = prefix + "/";
 
  for (int k = 0; k < keys.size(); ++k) {
  const std::string& key = keys[k];
  if ((key == prefix) || beginsWith(key, prefixSlash)) {
  m_cache.remove(keys[k]);
  }
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_copyFile	(	const std::string &	srcPath,
		const std::string &	dstPath
	)

private

Parameters

srcPath	Must name a file.
dstPath	Must not contain a zipfile.

Flushes the cache.

  {
  const std::string& source = FilePath::expandEnvironmentVariables(_source);
  const std::string& dest = FilePath::expandEnvironmentVariables(_dest);
 # ifdef G3D_WINDOWS
  // TODO: handle case where srcPath is in a zipfile
  CopyFileA(source.c_str(), dest.c_str(), FALSE);
  _clearCache(FilePath::parent(_resolve(dest)));
 # else
  // Read it all in, then dump it out
  BinaryInput in(source, G3D_LITTLE_ENDIAN);
  BinaryOutput out(dest, G3D_LITTLE_ENDIAN);
  out.writeBytes(in.getCArray(), in.size());
  out.commit(false);
 # endif 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_createDirectory ( const std::string & path )

private

Creates the directory named, including any subdirectories that do not already exist.

The directory must not be inside a zipfile.

Flushes the cache.

  {
  const std::string& dir = FilePath::expandEnvironmentVariables(_dir);
 
  if (dir == "") {
  return;
  }
  
  std::string d = _resolve(dir);
  
  // Add a trailing / if there isn't one.
  switch (d[d.size() - 1]) {
  case '/':
  case '\\':
  break;
 
  default:
  d += "/";
  }
 
  // If it already exists, do nothing
  if (_exists(FilePath::removeTrailingSlash(d))) {
  return;
  }
 
  // Parse the name apart
  std::string root, base, ext;
  Array<std::string> path;
 
  std::string lead;
  FilePath::parse(d, root, path, base, ext);
  debugAssert(base == "");
  debugAssert(ext == "");
 
  // Begin with an extra period so "c:\" becomes "c:\.\" after
  // appending a path and "c:" becomes "c:.\", not root: "c:\"
  std::string p = root + ".";
 
  // Create any intermediate that doesn't exist
  for (int i = 0; i < path.size(); ++i) {
  p += "/" + path[i];
  if (! _exists(p)) {
  // Windows only requires one argument to mkdir,
  // where as unix also requires the permissions.
 # ifndef G3D_WINDOWS
  mkdir(p.c_str(), 0777);
 # else
  _mkdir(p.c_str());
 # endif
  }
  }
 
  _clearCache(FilePath::parent(FilePath::removeTrailingSlash(d)));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FileSystem::_currentDirectory ( )

private

The current working directory (cwd). Only ends in a slash if this is the root of the file system.

  {
  static const int N = 2048;
  char buffer[N];
 
  (void)_getcwd(buffer, N);
  return std::string(buffer);
 }

Here is the caller graph for this function:

bool G3D::FileSystem::_exists	(	const std::string &	f,
		bool	trustCache = `true`,
		bool	caseSensitive = `true`
	)

private

Returns true if a node named f exists.

Parameters

f	If f contains wildcards, the function returns true if any file matches those wildcards. Wildcards may only appear in the base or ext, not the path. Environment variables beginning with dollar signs (e.g., in "$G3DDATA/cubemap"), with optional parens ("$(G3DDATA)") are automatically expanded in f. Default share names on Windows (e.g., "\\mycomputer\c$") are correctly distinguished from empty environment variables.
trustCache	If true, uses the cache for optimizing repeated calls in the same parent directory.
caseSensitive	If true, the match must have exactly the same case for the base and extension. If false, case is ignored. The default on Windows is false and the default on other operating systems is true.

  {
  const std::string& f = FilePath::expandEnvironmentVariables(_f);
 
  if (FilePath::isRoot(f)) {
 # ifdef G3D_WINDOWS
  const std::string& winname = toLower(f.substr(0, 1)) + ":\\";
  return _drives().contains(winname);
 # else
  return true;
 # endif
  }
 
  const std::string& path = FilePath::removeTrailingSlash(f);
  const std::string& parentPath = FilePath::parent(path);
 
  const bool forceUpdate = ! trustCache;
  const Dir& entry = getContents(parentPath, forceUpdate);
 
  if (FilePath::containsWildcards(f)) {
  if (! entry.exists) {
  // The directory didn't exist, so neither do its contents
  return false;
  } 
 
  const std::string& pattern = FilePath::baseExt(path);
 
  // See if any element of entry matches the wild card
  for (int i = 0; i < entry.nodeArray.size(); ++i) {
  if (FilePath::matches(entry.nodeArray[i].name, pattern, caseSensitive)) {
  return true;
  }
  }
 
  // Could not find a match
  return false;
 
  } else {
  return entry.exists && entry.contains(FilePath::baseExt(path), caseSensitive);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

FILE * G3D::FileSystem::_fopen	(	const char *	filename,
		const char *	mode
	)

private

Same as the C standard library fopen, but updates the file cache to acknowledge the new file on a write operation.

  {
  const std::string& filename = FilePath::canonicalize(FilePath::expandEnvironmentVariables(_filename));
 
  for (const char* m = mode; *m != '\0'; ++m) {
  if (*m == 'w') {
  // Purge the cache entry for the parent of this directory
  _clearCache(FilePath::parent(_resolve(filename)));
  break;
  }
  }
 
  markFileUsed(filename);
  return ::fopen(filename.c_str(), mode);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_getDirectories	(	const std::string &	spec,
		Array< std::string > &	result,
		bool	includeParentPath = `false`
	)

inlineprivate

list() directories

  {
  ListSettings set;
  set.includeParentPath = includeParentPath;
  set.directories = true;
  set.files = false;
  return list(spec, result, set);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_getFiles	(	const std::string &	spec,
		Array< std::string > &	result,
		bool	includeParentPath = `false`
	)

inlineprivate

list() files

  {
  ListSettings set;
  set.includeParentPath = includeParentPath;
  set.directories = false;
  set.files = true;
  return list(spec, result, set);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FileSystem::_inZipfile	(	const std::string &	path,
		std::string &	zipfile
	)

private

Returns true if some sub-path of path is a zipfile.

If the path itself is a zipfile, returns false.

Parameters

zipfile The part of path that was the zipfile

  {
  const std::string& path = FilePath::expandEnvironmentVariables(_path);
 
  // Reject trivial cases before parsing
 
  // Look at all sub-paths containing periods.
  // For each, ask if it is a zipfile.
  size_t current = 0;
  current = path.find('.', current);
 
  while (current != std::string::npos) {
  // xxxxx/foo.zip/yyyyy
  current = path.find('.', current);
 
  // Look forward for the next slash
  size_t s = findSlash(path, current);
 
  if (s == std::string::npos) {
  // No more slashes
  return false;
  }
 
  z = path.substr(0, s); 
  if (_isZipfile(z)) {
  return true;
  }
  
  current = s + 1;
  }
 
  z = "";
  return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FileSystem::_inZipfile ( const std::string & path )

inlineprivate

Returns true if some sub-path of path is a zipfile.

If the path itself is a zipfile, returns false.

Parameters

zipfile The part of path that was the zipfile

  {
  std::string ignore;
  return inZipfile(path, ignore);
  }

Here is the call graph for this function:

bool G3D::FileSystem::_isDirectory ( const std::string & path )

private

Known bug: does not work inside zipfiles

  {
  const std::string& filename = FilePath::expandEnvironmentVariables(_filename);
  // TODO: work with zipfiles and cache
  struct _stat st;
  const bool exists = _stat(FilePath::removeTrailingSlash(filename).c_str(), &st) != -1;
  return exists && ((st.st_mode & S_IFDIR) != 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FileSystem::_isFile ( const std::string & path )

inlineprivate

Known bug: does not work inside zipfiles

  {
  return ! isDirectory(path);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FileSystem::_isNewer	(	const std::string &	src,
		const std::string &	dst
	)

private

Returns true if dst does not exist or src is newer than dst, according to their time stamps.

Known bug: does not work inside zipfiles.

  {
  const std::string& src = FilePath::expandEnvironmentVariables(_src);
  const std::string& dst = FilePath::expandEnvironmentVariables(_dst);
 
  // TODO: work with cache and zipfiles
  struct _stat sts;
  bool sexists = _stat(src.c_str(), &sts) != -1;
 
  struct _stat dts;
  bool dexists = _stat(dst.c_str(), &dts) != -1;
 
  return sexists && ((! dexists) || (sts.st_mtime > dts.st_mtime));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FileSystem::_isZipfile ( const std::string & path )

private

Returns true if path is a file that is a zipfile. Note that G3D requires zipfiles to have some extension, although it is not required to be "zip"

  {
  const std::string& filename = FilePath::canonicalize(FilePath::expandEnvironmentVariables(_filename));
 
 
  
  FILE* f = fopen(FilePath::removeTrailingSlash(filename).c_str(), "r");
  if (f == NULL) {
  return false;
  }
  uint8 header[4];
  (void)fread(header, 4, 1, f);
  
  const uint8 zipHeader[4] = {0x50, 0x4b, 0x03, 0x04};
  for (int i = 0; i < 4; ++i) {
  if (header[i] != zipHeader[i]) {
  fclose(f);
  return false;
  }
  }
  
  fclose(f);
  return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_list	(	const std::string &	spec,
		Array< std::string > &	result,
		const ListSettings &	listSettings = `ListSettings()`
	)

private

Appends all nodes matching spec to the result array.

Wildcards can only appear to the right of the last slash in spec.

The names will not contain parent paths unless includePath == true. These may be relative to the current directory unless spec is fully qualified (can be done with resolveFilename).

  {
  const std::string& spec = FilePath::expandEnvironmentVariables(_spec);
 
  const std::string& shortSpec = FilePath::baseExt(spec);
  const std::string& parentPath = FilePath::parent(spec);
 
  listHelper(shortSpec, parentPath, result, settings);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_removeFile ( const std::string & path )

private

Delete this file. No effect if path does not exist.

Parameters

path	May contain wildcards. May not be inside a zipfile.

                                                   {
     alwaysAssertM(! inZipfile(path), "Cannot invoke removeFile() on files inside zipfiles.");
     Array<std::string> files;
     getFiles(path, files, true);
 
     for (int i = 0; i < files.size(); ++i) {
         const std::string& filename = files[i];
         int retval = ::remove(filename.c_str());
         (void)retval;
     }
     
     // Remove from cache
     _clearCache(FilePath::parent(path));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FileSystem::_resolve	(	const std::string &	path,
		const std::string &	cwd = `currentDirectory()`
	)

private

Fully qualifies a filename.

The filename may contain wildcards, in which case the wildcards will be preserved in the returned value.

Parameters

cwd	The directory to treat as the "current" directory when resolving a relative path. The default value is the actual current directory. (G3D::Any::sourceDirectory is a common alternative)

                                                                                 {
     const std::string& filename = FilePath::expandEnvironmentVariables(_filename);
     const std::string& cwd = FilePath::expandEnvironmentVariables(_cwd);
 
     if (filename.size() >= 1) {
         if (isSlash(filename[0])) {
             // Already resolved
             return filename;
         } else {
 
             #ifdef G3D_WINDOWS
                 if ((filename.size() >= 2) && (filename[1] == ':')) {
                     // There is a drive spec on the front.
                     if ((filename.size() >= 3) && isSlash(filename[2])) {
                         // Already fully qualified
                         return filename;
                     } else {
                         // The drive spec is relative to the
                         // working directory on that drive.
                         debugAssertM(false, "Files of the form d:path are"
                                      " not supported (use a fully qualified"
                                      " name).");
                         return filename;
                     }
                 }
             #endif
         }
     }
 
     // Prepend the working directory.
     return FilePath::concat(cwd, filename);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::_setCacheLifetime ( float t )

private

Set the cacheLifetime().

Parameters

t	in seconds

                                           {
     m_cacheLifetime = t;
 }

Here is the caller graph for this function:

int64 G3D::FileSystem::_size ( const std::string & path )

private

Returns the length of the file in bytes, or -1 if the file could not be opened.

                                                   {
     const std::string& filename = FilePath::canonicalize(FilePath::expandEnvironmentVariables(_filename));
 
     struct stat64 st;
     int result = stat64(filename.c_str(), &st);
     
     if (result == -1) {
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
         std::string zip, contents;
         if (zipfileExists(filename, zip, contents)) {
             int64 requiredMem;
             
             struct zip *z = zip_open( zip.c_str(), ZIP_CHECKCONS, NULL );
             debugAssertM(z != NULL, zip + ": zip open failed.");
             {
                 struct zip_stat info;
                 zip_stat_init( &info );    // Docs unclear if zip_stat_init is required.
                 int success = zip_stat( z, contents.c_str(), ZIP_FL_NOCASE, &info );
                 (void) success;
                 debugAssertM(success == 0, zip + ": " + contents + ": zip stat failed.");
                 requiredMem = info.size;
             }
             zip_close(z);
             return requiredMem;
         } else {
 #endif
             return -1;
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
          }
 #endif
     }
     
     return st.st_size;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static float G3D::FileSystem::cacheLifetime ( )

inlinestatic

A cache is used to optimize repeated calls. A cache entry is considered valid for this many seconds after it has been checked.

                                  {
         mutex.lock();
         float f = instance()._cacheLifetime();
         mutex.unlock();
         return f;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::cleanup ( )

static

Destroy the common instance.

                          {
     if (common != NULL) {
         delete common;
         common = NULL;
     }
 }

static void G3D::FileSystem::clearCache ( const std::string & path = "" )

inlinestatic

Clears old cache entries so that exists() and list() will reflect recent changes to the file system.

Parameters

path	Clear only path and its subdirectories ("" means clear the entire cache)

                                                        {
         mutex.lock();
         instance()._clearCache(path);
         mutex.unlock();
     }

Here is the call graph for this function:

static void G3D::FileSystem::copyFile	(	const std::string &	srcPath,
		const std::string &	dstPath
	)

inlinestatic

Parameters

srcPath	Must name a file.
dstPath	Must not contain a zipfile.

Flushes the cache.

                                                                              {
         mutex.lock();
         instance()._copyFile(srcPath, dstPath);
         mutex.unlock();
     }

Here is the call graph for this function:

static void G3D::FileSystem::createDirectory ( const std::string & path )

inlinestatic

Creates the directory named, including any subdirectories that do not already exist.

The directory must not be inside a zipfile.

Flushes the cache.

                                                        {
         mutex.lock();
         instance()._createDirectory(path);
         mutex.unlock();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string G3D::FileSystem::currentDirectory ( )

inlinestatic

The current working directory (cwd). Only ends in a slash if this is the root of the file system.

                                         {
         mutex.lock();
         const std::string& s = instance()._currentDirectory();
         mutex.unlock();
         return s;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::FileSystem::exists	(	const std::string &	f,
		bool	trustCache = `true`,
		bool	caseSensitive = `true`
	)

inlinestatic

Returns true if a node named f exists.

Parameters

f	If f contains wildcards, the function returns true if any file matches those wildcards. Wildcards may only appear in the base or ext, not the path. Environment variables beginning with dollar signs (e.g., in "$G3DDATA/cubemap"), with optional parens ("$(G3DDATA)") are automatically expanded in f. Default share names on Windows (e.g., "\\mycomputer\c$") are correctly distinguished from empty environment variables.
trustCache	If true, uses the cache for optimizing repeated calls in the same parent directory.
caseSensitive	If true, the match must have exactly the same case for the base and extension. If false, case is ignored. The default on Windows is false and the default on other operating systems is true.

           {
         mutex.lock();
         bool e = instance()._exists(f, trustCache, caseSensitive);
         mutex.unlock();
         return e;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::FileSystem::fclose ( FILE * f )

inlinestatic

                                 {
         mutex.lock();
         ::fclose(f);
         mutex.unlock();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static FILE* G3D::FileSystem::fopen	(	const char *	filename,
		const char *	mode
	)

inlinestatic

Same as the C standard library fopen, but updates the file cache to acknowledge the new file on a write operation.

                                                                {
         mutex.lock();
         FILE* f = instance()._fopen(filename, mode);
         mutex.unlock();
         return f;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

FileSystem::Dir & G3D::FileSystem::getContents	(	const std::string &	path,
		bool	forceUpdate
	)

private

Update the cache entry for path if it is not already present.

Parameters

forceUpdate If true, always override the current cache value.

                                                                               {
     const std::string& key = 
 #   if defined(G3D_WINDOWS)
         FilePath::canonicalize(FilePath::removeTrailingSlash(toLower(FilePath::canonicalize(resolve(path)))));
 #   else
         FilePath::canonicalize(FilePath::removeTrailingSlash(FilePath::canonicalize(resolve(path))));
 #   endif
     
     RealTime now = System::time();
     Dir& dir = m_cache.getCreate(key);
 
     if ((now > dir.lastChecked + cacheLifetime()) || forceUpdate) {
         dir = Dir();
 
         // Out of date: update
         dir.lastChecked = now;
 #       ifdef G3D_WINDOWS
             // On windows, we have to use GetFileAttributes (http://msdn.microsoft.com/en-us/library/aa364944(v=vs.85).aspx) instead of 
             // stat in order to work with network shares
             const DWORD st = GetFileAttributesA(key.c_str());
             const bool exists = (st != INVALID_FILE_ATTRIBUTES);
             const bool isDirectory = (st & FILE_ATTRIBUTE_DIRECTORY) != 0;
 #       else
             struct _stat st;
             const bool exists = _stat(key.c_str(), &st) != -1;
             const bool isDirectory = (st.st_mode & S_IFDIR) != 0;
 #       endif
 
         // Does this path exist on the real filesystem?
         if (exists && isDirectory) {
 
             // Is this path actually a directory?
             if (isDirectory) {
                 dir.exists = true;
                 // Update contents
 #               ifdef G3D_WINDOWS
                     const std::string& filespec = FilePath::concat(key, "*");
                     struct _finddata_t fileinfo;
                     intptr_t handle = _findfirst(filespec.c_str(), &fileinfo);
                     debugAssert(handle != -1);
                     int result = 0;
                     do {
                         if ((strcmp(fileinfo.name, ".") != 0) && (strcmp(fileinfo.name, "..") != 0)) {
                             Entry& e = dir.nodeArray.next();
                             e.name = fileinfo.name;
                             if ((fileinfo.attrib & _A_SUBDIR) != 0) {
                                 e.type = DIR_TYPE;
                             } else {
                                 e.type = FILE_TYPE;
                             }
                         }
 
                         result = _findnext(handle, &fileinfo);
                     } while (result == 0);
                     _findclose(handle);
 
 #               else
                     DIR* listing = opendir(key.c_str());
                     debugAssertM(listing, "opendir failed on '" + key + "'");
                     struct dirent* entry = readdir(listing);
                     while (entry != NULL) {
                         if ((strcmp(entry->d_name, "..") != 0) && (strcmp(entry->d_name, ".") != 0)) {
                             Entry& e = dir.nodeArray.next();
                             e.name = entry->d_name;
 
 #                           ifdef _DIRENT_HAVE_D_TYPE
                                 // Not all POSIX systems support this field
                                 // http://www.delorie.com/gnu/docs/glibc/libc_270.html
                                 switch (entry->d_type) {
                                 case DT_DIR:
                                     e.type = DIR_TYPE;
                                     break;
                                     
                                 case DT_REG:
                                     e.type = FILE_TYPE;
                                     break;
                                     
                                 case DT_UNKNOWN:
                                 default:
                                     e.type = UNKNOWN;
                                     break;
                                 }
 #                           endif
                         }
                         entry = readdir(listing);
                     }
                     closedir(listing);
                     listing = NULL;
                     entry = NULL;
 #               endif
             }
 
         } else {
             std::string zip;
 
             if (exists && isZipfile(path)) {
                 // This is a zipfile; get its root
                 dir.isZipfile = true;                
                 dir.computeZipListing(path, "");
 
             } else if (inZipfile(path, zip)) {
 
                 // There is a zipfile somewhere in the path.  Does
                 // the rest of the path exist inside the zipfile?
                 dir.inZipfile = true;
                 dir.computeZipListing(zip, path.substr(zip.length() + 1));
             }
         }        
     }
 
     return dir;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::FileSystem::getDirectories	(	const std::string &	spec,
		Array< std::string > &	result,
		bool	includeParentPath = `false`
	)

inlinestatic

list() directories

                                                                                                                 {
         mutex.lock();
         instance()._getDirectories(spec, result, includeParentPath);
         mutex.unlock();
     }

Here is the call graph for this function:

static void G3D::FileSystem::getFiles	(	const std::string &	spec,
		Array< std::string > &	result,
		bool	includeParentPath = `false`
	)

inlinestatic

list() files

                                                                                                           {
         mutex.lock();
         instance()._getFiles(spec, result, includeParentPath);
         mutex.unlock();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::init ( )

static

Create the common instance.

                       {
     if (common == NULL) {
         common = new FileSystem();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

FileSystem & G3D::FileSystem::instance ( )

staticprivate

                                  {
     init();
     return *common;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::FileSystem::inZipfile	(	const std::string &	path,
		std::string &	zipfile
	)

inlinestatic

Returns true if some sub-path of path is a zipfile.

If the path itself is a zipfile, returns false.

Parameters

zipfile The part of path that was the zipfile

                                                                      {
         mutex.lock();
         bool b = instance()._inZipfile(path, zipfile);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::FileSystem::inZipfile ( const std::string & path )

inlinestatic

Returns true if some sub-path of path is a zipfile.

If the path itself is a zipfile, returns false.

                                                  {
         mutex.lock();
         bool b = instance()._inZipfile(path);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

bool efsw::Platform::FileSystem::isDirectory ( const std::string & path )

inlinestatic

Known bug: does not work inside zipfiles

                                                    {
         mutex.lock();
         bool b = instance()._isDirectory(path);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::FileSystem::isFile ( const std::string & path )

inlinestatic

Known bug: does not work inside zipfiles

                                               {
         mutex.lock();
         bool b = instance()._isFile(path);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

static bool G3D::FileSystem::isNewer	(	const std::string &	src,
		const std::string &	dst
	)

inlinestatic

Returns true if dst does not exist or src is newer than dst, according to their time stamps.

Known bug: does not work inside zipfiles.

                                                                     {
         mutex.lock();
         bool b = instance()._isNewer(src, dst);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

static bool G3D::FileSystem::isZipfile ( const std::string & path )

inlinestatic

Returns true if path is a file that is a zipfile. Note that G3D requires zipfiles to have some extension, although it is not required to be "zip"

                                                  {
         mutex.lock();
         bool b = instance()._isZipfile(path);
         mutex.unlock();
         return b;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::FileSystem::list	(	const std::string &	spec,
		Array< std::string > &	result,
		const ListSettings &	listSettings = `ListSettings()`
	)

inlinestatic

Appends all nodes matching spec to the result array.

Wildcards can only appear to the right of the last slash in spec.

The names will not contain parent paths unless includePath == true. These may be relative to the current directory unless spec is fully qualified (can be done with resolveFilename).

                                                            {
         mutex.lock();
         instance()._list(spec, result, listSettings);
         mutex.unlock();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::listHelper	(	const std::string &	shortSpec,
		const std::string &	parentPath,
		Array< std::string > &	result,
		const ListSettings &	settings
	)

private

Called from list()

                                {
 
     Dir& dir = getContents(parentPath, false);
 
     if (! dir.exists) {
         return;
     }
 
     for (int i = 0; i < dir.nodeArray.size(); ++i) {
         Entry& entry = dir.nodeArray[i];
         // See if it matches the spec
         if (FilePath::matches(entry.name, shortSpec, settings.caseSensitive)) {
 
             if ((entry.type == UNKNOWN) && 
                 (! (settings.files && settings.directories) ||
                  settings.recursive)) {
                 // Update the type: it is unknown and we'll need to branch onit below
                 entry.type = isDirectory(FilePath::concat(parentPath, entry.name)) ? DIR_TYPE : FILE_TYPE;
             }
             
             if ((settings.files && settings.directories) ||
                 (settings.files && (entry.type == FILE_TYPE)) ||
                 (settings.directories && (entry.type == DIR_TYPE))) {
                 
                 if (settings.includeParentPath) {
                     result.append(FilePath::concat(parentPath, entry.name));
                 } else {
                     result.append(entry.name);
                 }
             }
         } // match
   
         if (settings.recursive) {
             if (entry.type == UNKNOWN) {
                 entry.type = isDirectory(FilePath::concat(parentPath, entry.name)) ? DIR_TYPE : FILE_TYPE;
             }
 
             if (entry.type == DIR_TYPE) {
                 listHelper(shortSpec, FilePath::concat(parentPath, entry.name), result, settings);
             }
         }
     } // for
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::markFileUsed ( const std::string & filename )

static

Adds filename to usedFiles(). This is called automatically by open() and all G3D routines that open files.

                                                        {
     mutex.lock();
     _filesUsed.insert(filename);
     mutex.unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::FileSystem::removeFile ( const std::string & path )

inlinestatic

Delete this file. No effect if path does not exist.

Parameters

path	May contain wildcards. May not be inside a zipfile.

                                                   {
         mutex.lock();
         instance()._removeFile(path);
         mutex.unlock();
     }

Here is the call graph for this function:

static std::string G3D::FileSystem::resolve	(	const std::string &	path,
		const std::string &	cwd = `currentDirectory()`
	)

inlinestatic

Fully qualifies a filename.

The filename may contain wildcards, in which case the wildcards will be preserved in the returned value.

Parameters

cwd	The directory to treat as the "current" directory when resolving a relative path. The default value is the actual current directory. (G3D::Any::sourceDirectory is a common alternative)

                                                                                                {
         mutex.lock();
         const std::string& s = instance()._resolve(path, cwd);
         mutex.unlock();
         return s;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::FileSystem::setCacheLifetime ( float t )

inline

Set the cacheLifetime().

Parameters

t	in seconds

                                    {
         mutex.lock();
         instance()._setCacheLifetime(t);
         mutex.unlock();
     }

Here is the call graph for this function:

static int64 G3D::FileSystem::size ( const std::string & path )

inlinestatic

Returns the length of the file in bytes, or -1 if the file could not be opened.

                                              {
         mutex.lock();
         int64 i = instance()._size(path);
         mutex.unlock();
         return i;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

const Set< std::string > & G3D::FileSystem::usedFiles ( )

static

All files that have been marked by markFileUsed(). GApp automatically prints this list to log.txt. It is useful for finding the dependencies of your program automatically.

                                             {
     return _filesUsed;
 }

Member Data Documentation

Table<std::string, Dir> G3D::FileSystem::m_cache

private

Maps path names (without trailing slashes, except for the file system root) to contents. On Windows, all paths are lowercase

float G3D::FileSystem::m_cacheLifetime

private

Array<std::string> G3D::FileSystem::m_winDrive

private

Drive letters. Only used on windows, but defined on all platforms to help avoid breaking the Windows build when compiling on another platform.

GMutex G3D::FileSystem::mutex

staticprivate

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

dep/g3dlite/include/G3D/FileSystem.h
dep/efsw/src/efsw/FileSystem.cpp
dep/efsw/src/efsw/platform/win/FileSystemImpl.cpp

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation