FileSystem.h

Go to the documentation of this file.

#ifndef G3D_FileSystem_h
#define G3D_FileSystem_h

#include "G3D/platform.h"
#include "G3D/Array.h"
#include "G3D/Table.h"
#include "G3D/Set.h"
#include "G3D/GMutex.h"

namespace G3D {

class FileSystem {
public:

 class ListSettings {
 public:
 bool files;

 bool directories;

 bool caseSensitive;

 bool recursive;

 bool includeParentPath;

 ListSettings() :
 files(true),
 directories(true),
# ifdef G3D_WINDOWS
 caseSensitive(true),
# else
 caseSensitive(false),
# endif
 recursive(false),
 includeParentPath(true) {}
 };

private:

 Array<std::string> m_winDrive;

 float m_cacheLifetime;

 enum Type {
 UNKNOWN, 
 FILE_TYPE, 
 DIR_TYPE
 };

 class Entry {
 public: 
 std::string name;
 Type type;
 Entry() : type(UNKNOWN) {}
 Entry(const char* n) : name(n), type(UNKNOWN) {}
 };

 class Dir {
 public:
 
 bool exists;

 bool isZipfile;
 bool inZipfile;

 Array<Entry> nodeArray;
 
 double lastChecked;

 bool contains(const std::string& child, bool caseSensitive =
#ifdef G3D_WINDOWS
 false
#else
 true
#endif
) const;

 void computeZipListing(const std::string& zipfile, const std::string& pathInsideZipfile);

 Dir() : exists(false), isZipfile(false), inZipfile(false), lastChecked(0) {}
 };

 Table<std::string, Dir> m_cache;

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

 FileSystem();

 static FileSystem& instance();
 static GMutex mutex;


# ifdef G3D_WINDOWS

 const Array<std::string>& _drives();
# endif 

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

 void _clearCache(const std::string& path);

 bool _inZipfile(const std::string& path) {
 std::string ignore;
 return inZipfile(path, ignore);
 }

 void _setCacheLifetime(float t);


 float _cacheLifetime() const {
 return m_cacheLifetime;
 }

 void _createDirectory(const std::string& path);

 bool _exists(const std::string& f, bool trustCache = true, bool caseSensitive = 
#ifdef G3D_WINDOWS
 false
#else
 true
#endif
 );

 bool _isDirectory(const std::string& path);
 
 bool _isFile(const std::string& path) {
 return ! isDirectory(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) {
 ListSettings set;
 set.includeParentPath = includeParentPath;
 set.directories = false;
 set.files = true;
 return list(spec, result, set);
 }

 void _getDirectories(const std::string& spec, Array<std::string>& result, bool includeParentPath = false) {
 ListSettings set;
 set.includeParentPath = includeParentPath;
 set.directories = true;
 set.files = false;
 return list(spec, result, set);
 }

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

 void _removeFile(const std::string& path);

public:

 static void init();

 static void cleanup();

# ifdef G3D_WINDOWS

 static const Array<std::string>& drives() {
 mutex.lock();
 const Array<std::string>& s = instance()._drives();
 mutex.unlock();
 return s;
 }
# endif

 static bool inZipfile(const std::string& path, std::string& zipfile) {
 mutex.lock();
 bool b = instance()._inZipfile(path, zipfile);
 mutex.unlock();
 return b;
 }

 static void clearCache(const std::string& path = "") {
 mutex.lock();
 instance()._clearCache(path);
 mutex.unlock();
 }

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


 static void fclose(FILE* f) {
 mutex.lock();
 ::fclose(f);
 mutex.unlock();
 }

 static bool inZipfile(const std::string& path) {
 mutex.lock();
 bool b = instance()._inZipfile(path);
 mutex.unlock();
 return b;
 }

 
 static void removeFile(const std::string& path) {
 mutex.lock();
 instance()._removeFile(path);
 mutex.unlock();
 }

 
 static bool isZipfile(const std::string& path) {
 mutex.lock();
 bool b = instance()._isZipfile(path);
 mutex.unlock();
 return b;
 }

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

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

 
 static void createDirectory(const std::string& path) {
 mutex.lock();
 instance()._createDirectory(path);
 mutex.unlock();
 }

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

 
 static void copyFile(const std::string& srcPath, const std::string& dstPath) {
 mutex.lock();
 instance()._copyFile(srcPath, dstPath);
 mutex.unlock();
 }

 

 static bool exists(const std::string& f, bool trustCache = true, bool caseSensitive = 
#ifdef G3D_WINDOWS
 false
#else
 true
#endif
 ) {
 mutex.lock();
 bool e = instance()._exists(f, trustCache, caseSensitive);
 mutex.unlock();
 return e;
 }

 
 static bool isDirectory(const std::string& path) {
 mutex.lock();
 bool b = instance()._isDirectory(path);
 mutex.unlock();
 return b;
 }

 
 static bool isFile(const std::string& path) {
 mutex.lock();
 bool b = instance()._isFile(path);
 mutex.unlock();
 return b;
 }

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

 
 static bool isNewer(const std::string& src, const std::string& dst) {
 mutex.lock();
 bool b = instance()._isNewer(src, dst);
 mutex.unlock();
 return b;
 }

 
 static int64 size(const std::string& path) {
 mutex.lock();
 int64 i = instance()._size(path);
 mutex.unlock();
 return i;
 }

 
 static void list(const std::string& spec, Array<std::string>& result,
 const ListSettings& listSettings = ListSettings()) {
 mutex.lock();
 instance()._list(spec, result, listSettings);
 mutex.unlock();
 }

 
 static void getFiles(const std::string& spec, Array<std::string>& result, bool includeParentPath = false) {
 mutex.lock();
 instance()._getFiles(spec, result, includeParentPath);
 mutex.unlock();
 }

 
 static void getDirectories(const std::string& spec, Array<std::string>& result, bool includeParentPath = false) {
 mutex.lock();
 instance()._getDirectories(spec, result, includeParentPath);
 mutex.unlock();
 }

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

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


class FilePath {
public:

 static std::string concat(const std::string& a, const std::string& b);

 static bool isRoot(const std::string& f);

 static std::string removeTrailingSlash(const std::string& f);

 static std::string ext(const std::string& path);

 static std::string baseExt(const std::string& path);

 static std::string base(const std::string& path);

 static std::string parent(const std::string& path);

 static bool containsWildcards(const std::string& p);

 static std::string canonicalize(std::string x);

 static std::string expandEnvironmentVariables(const std::string& path);

 static void parse
 (const std::string& filename,
 std::string& drive, 
 Array<std::string>& path,
 std::string& base,
 std::string& ext);

 static bool matches(const std::string& path, const std::string& pattern, bool caseSensitive = true);

 static std::string makeLegalFilename(const std::string& f, size_t maxLength = 100000);
};

} // namespace G3D
#endif