G3D::FilePath Class Reference

Parsing of file system paths. More...

#include <FileSystem.h>

Static Public Member Functions
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)
	Replaces $VAR and patterns with the corresponding environment variable. Throws std::string if the environment variable is not defined. More...
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)

Detailed Description

Parsing of file system paths.

None of these routines touch the disk–they are purely string manipulation.

In "/a/b/base.ext",

• base = "base"
• ext = "ext"
• parentPath = "/a/b"
• baseExt = "base.ext"

Member Function Documentation

std::string G3D::FilePath::base ( const std::string &  path )

static

Returns everything between the right-most slash and the following '.'

 {
 std::string filename = baseExt(path);
 size_t i = filename.rfind(".");
 if (i == std::string::npos) {
 // No extension
 return filename;
 } else {
 return filename.substr(0, i);
 }
}

std::string G3D::FilePath::baseExt ( const std::string &  path )

static

Returns everything to the right of the last slash (or, on Windows, the last ':')

 {
 size_t i = findLastSlash(filename);

# ifdef G3D_WINDOWS
 size_t j = filename.rfind(":");
 if ((i == std::string::npos) && (j != std::string::npos)) {
 i = j;
 }
# endif

 if (i == std::string::npos) {
 return filename;
 } else {
 return filename.substr(i + 1, filename.length() - i);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::canonicalize ( std::string  x )

static

Convert all slashes to '/'

 {
 std::transform(x.begin(), x.end(), x.begin(), fixslash);
 return x;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::concat ( const std::string &  a, const std::string &  b  )

static

Appends file onto dirname, ensuring a / if needed.

 {
 // Ensure that the directory ends in a slash
 if (! dirname.empty() && 
 ! isSlash(dirname[dirname.size() - 1]) &&
 (dirname[dirname.size() - 1] != ':')) {
 return dirname + '/' + file;
 } else {
 return dirname + file;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::FilePath::containsWildcards ( const std::string &  p )

static

Returns true if '*' or '?' appear in the filename

 {
 return (filename.find('*') != std::string::npos) || (filename.find('?') != std::string::npos);
}

Here is the caller graph for this function:

std::string G3D::FilePath::expandEnvironmentVariables ( const std::string &  path )

static

Replaces $VAR and patterns with the corresponding environment variable. Throws std::string if the environment variable is not defined.

 {
 // Search for pattern
 size_t end = path.find_first_of('$', 0);
 if (end == std::string::npos) {
 // Pattern does not exist
 return path;
 }

 size_t start = 0;
 std::string result;
 while (end != std::string::npos) {
 const std::string& before = path.substr(start, end - start);
 result += before;
 start = end + 1;
 std::string var;
 if (path[start] == '(') {
 // Search for close paren
 end = path.find_first_of(')', start + 1);
 if (end == std::string::npos) {
 throw std::string("Missing close paren in environment variable in \"") + path + "\"";
 }
 var = path.substr(start + 1, end - start - 1);
 } else {
 // Search for slash or end of string
 end = path.find_first_of('/', start);
 size_t i = path.find_first_of('\\', start);
 if ((size_t(i) != std::string::npos) && ((end == std::string::npos) || (size_t(i) < end))) {
 end = i;
 }
 if (end == std::string::npos) {
 // If the varible goes to the end of the string, it is the rest of the string
 end = path.size();
 } else {
 --end;
 }
 var = path.substr(start, end - start + 1);
 }

 if (! var.empty()) {
 const char* value = getenv(var.c_str());

 if (value == NULL) {
 throw (std::string("LocalLightingEnvironment variable \"") + var + "\" not defined for path \"" + path + "\"");
 } else {
 result += value;
 }
 } else {
 // We just parsed an "empty" variable, which was probably a default share on Windows, e.g.,
 // "\\mycomputer\c$", and not a variable name.
 result += "$"; 
 }

 start = end + 1;
 end = path.find_first_of('$', start);
 }

 // Paste on the remainder of the source path
 if (start < path.size()) {
 result += path.substr(start);
 }

 return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::ext ( const std::string &  path )

static

Returns everything to the right of the last '.'

 {
 size_t i = filename.rfind(".");
 if (i != std::string::npos) {
 return filename.substr(i + 1, filename.length() - i);
 } else {
 return "";
 }
}

Here is the caller graph for this function:

bool G3D::FilePath::isRoot ( const std::string &  f )

static

Returns true if f specifies a path that parses as root of the filesystem. On OS X and other Unix-based operating systems, "/" is the only root. On Windows, drive letters and shares are roots, e.g., "c:\", "\\foo\". Does not check on Windows to see if the root is actually mounted or a legal drive letter–this is a purely string based test.

 {
# ifdef G3D_WINDOWS
 if (f.length() < 2) {
 return false;
 }

 if (f[1] == ':') {
 if (f.length() == 2) {
 // e.g., "x:"
 return true;
 } else if ((f.length() == 3) && isSlash(f[2])) {
 // e.g., "x:\"
 return true;
 }
 }

 // Windows shares are considered roots, but only if this does not include a path inside the share
 if (isSlash(f[0]) && isSlash(f[1])) {
 size_t i = f.find("/", 3);
 size_t j = f.find("\\", 3);

 if (i == std::string::npos) {
 i = j;
 }

 // e.g., "\\foo\", "\\foo"
 return ((i == std::string::npos) || (i == f.length() - 1));
 }
# else
 if (f == "/") {
 return true;
 }
# endif

 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::makeLegalFilename ( const std::string &  f, size_t  maxLength = 100000  )

static

Replaces characters that are illegal in a filename with legal equivalents.

Generate a unique filename based on the provided hint

 {
 std::string tentative;
 
 for (size_t i = 0; i < G3D::min(maxLength, f.size()); ++i) {
 const char c = f[i];
 if (isLetter(c) || isDigit(c) || (c == '-') || (c == '+') || (c == '=') || (c == '(') || (c == ')')) {
 tentative += c;
 } else {
 tentative += "_";
 }
 }

 return tentative;
}

Here is the call graph for this function:

bool G3D::FilePath::matches ( const std::string &  path, const std::string &  pattern, bool  caseSensitive = true  )

static

Returns true if path matches pattern, with standard filesystem wildcards.

 {
 int flags = FNM_PERIOD | FNM_NOESCAPE | FNM_PATHNAME;
 if (! caseSensitive) {
 flags |= FNM_CASEFOLD;
 }
 return g3dfnmatch(pattern.c_str(), path.c_str(), flags) == 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::parent ( const std::string &  path )

static

Returns everything to the left of the right-most slash

 { 
 size_t i = findLastSlash(removeTrailingSlash(path));

# ifdef G3D_WINDOWS
 size_t j = path.rfind(":");
 if ((i == std::string::npos) && (j != std::string::npos)) {
 i = j;
 }
# endif

 if (i == std::string::npos) {
 return "";
 } else {
 return path.substr(0, i + 1);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Parses a filename into four useful pieces.

Examples:

c:\a\b\d.e root = "c:\\" path = "a" "b" base = "d" ext = "e"

/a/b/d.e root = "/" path = "a" "b" base = "d" ext = "e"

/a/b root = "/" path = "a" base = "b" ext = "e"

 {

 std::string f = filename;

 root = "";
 path.clear();
 base = "";
 ext = "";

 if (f == "") {
 // Empty filename
 return;
 }

 // See if there is a root/drive spec.
 if ((f.size() >= 2) && (f[1] == ':')) {
 
 if ((f.size() > 2) && isSlash(f[2])) {
 
 // e.g. c:\foo
 root = f.substr(0, 3);
 f = f.substr(3, f.size() - 3);
 
 } else {
 
 // e.g. c:foo
 root = f.substr(2);
 f = f.substr(2, f.size() - 2);

 }

 } else if ((f.size() >= 2) && isSlash(f[0]) && isSlash(f[1])) {
 
 // e.g. //foo
 root = f.substr(0, 2);
 f = f.substr(2, f.size() - 2);

 } else if (isSlash(f[0])) {
 
 root = f.substr(0, 1);
 f = f.substr(1, f.size() - 1);

 }

 // Pull the extension off
 {
 // Find the period
 size_t i = f.rfind('.');

 if (i != std::string::npos) {
 // Make sure it is after the last slash!
 size_t j = findLastSlash(f);
 if ((j == std::string::npos) || (i > j)) {
 ext = f.substr(i + 1, f.size() - i - 1);
 f = f.substr(0, i);
 }
 }
 }

 // Pull the basename off
 {
 // Find the last slash
 size_t i = findLastSlash(f);
 
 if (i == std::string::npos) {
 
 // There is no slash; the basename is the whole thing
 base = f;
 f = "";

 } else if ((i != std::string::npos) && (i < f.size() - 1)) {
 
 base = f.substr(i + 1, f.size() - i - 1);
 f = f.substr(0, i);

 }
 }

 // Parse what remains into path.
 size_t prev, cur = 0;

 while (cur < f.size()) {
 prev = cur;
 
 // Allow either slash
 size_t i = f.find('/', prev + 1);
 size_t j = f.find('\\', prev + 1);
 if (i == std::string::npos) {
 i = f.size();
 }

 if (j == std::string::npos) {
 j = f.size();
 }

 cur = min(i, j);

 if (cur == std::string::npos) {
 cur = f.size();
 }

 path.append(f.substr(prev, cur - prev));
 ++cur;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::FilePath::removeTrailingSlash ( const std::string &  f )

static

Removes the trailing slash unless f is a filesystem root

 {
 bool removeSlash = ((endsWith(f, "/") || endsWith(f, "\\"))) && ! isRoot(f);

 return removeSlash ? f.substr(0, f.length() - 1) : f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• dep/g3dlite/include/G3D/FileSystem.h
• dep/g3dlite/source/FileSystem.cpp