pfc::io::path Namespace Reference

Typedefs
typedef string::comparatorCaseInsensitive	comparator

Functions
string	combine (string basePath, string fileName)
template<typename t1 , typename t2 >
int	compare (t1 const &p1, t2 const &p2)
template<typename t1 , typename t2 >
bool	equals (const t1 &v1, const t2 &v2)
static const string	g_illegalNameChars (g_pathSeparators#ifdef _WINDOWS+":<>*?\""#else+"*?"#endif)
static const string	g_illegalNameChars_noWC (g_pathSeparators#ifdef _WINDOWS+":<>?\""#endif)
static const string	g_pathSeparators ("/")
char	getDefaultSeparator ()
string	getDirectory (string filePath)
string	getFileExtension (string path)
string	getFileName (string path)
string	getFileNameWithoutExtension (string path)
string	getIllegalNameChars (bool allowWC)
string	getParent (string filePath)
string	getSeparators ()
bool	isDirectoryRoot (string path)
static bool	isIllegalTrailingChar (char c)
bool	isInsideDirectory (pfc::string directory, pfc::string inside)
bool	isSeparator (char c)
static string	replaceIllegalChar (char c)
string	replaceIllegalNameChars (string fn, bool allowWC)
string	replaceIllegalPathChars (string fn)
string	validateFileName (string name, bool allowWC)

Variables
static const string	g_pathSeparators ("\\/|")

Typedef Documentation

typedef string::comparatorCaseSensitive pfc::io::path::comparator

Definition at line 5 of file pathUtils.h.

Function Documentation

string pfc::io::path::combine	(	string	basePath,
		string	fileName
	)

Definition at line 41 of file pathUtils.cpp.

                                                {
    if (basePath.length() > 0) {
        if (!isSeparator(basePath.lastChar())) {
            basePath += getDefaultSeparator();
        }
        return basePath + fileName;
    } else {
        //todo?
        return fileName;
    }
}

template<typename t1 , typename t2 >

int pfc::io::path::compare ( t1 const &  p1, t2 const &  p2  )

inline

Definition at line 29 of file pathUtils.h.

{return comparator::compare(p1, p2); }

template<typename t1 , typename t2 >

bool pfc::io::path::equals ( const t1 &  v1, const t2 &  v2  )

inline

Definition at line 27 of file pathUtils.h.

{return comparator::compare(v1,v2) == 0;}

static const string pfc::io::path::g_illegalNameChars ( g_pathSeparators#ifdef _WINDOWS+":<>*?\""#else+"*?"#  endif )

static

static const string pfc::io::path::g_illegalNameChars_noWC ( g_pathSeparators#ifdef _WINDOWS+":<>?\""#  endif )

static

static const string pfc::io::path::g_pathSeparators ( "/"  )

static

char pfc::io::path::getDefaultSeparator

(

)

Definition at line 124 of file pathUtils.cpp.

                           {
#ifdef _WINDOWS
    return '\\';
#else
    return '/';
#endif
}

string pfc::io::path::getDirectory

(

string

filePath

)

Definition at line 28 of file pathUtils.cpp.

{return getParent(filePath);}

string pfc::io::path::getFileExtension

(

string

path

)

Definition at line 22 of file pathUtils.cpp.

                                     {
    string fn = getFileName(path);
    t_size split = fn.lastIndexOf('.');
    if (split == ~0) return "";
    else return fn.subString(split);
}

string pfc::io::path::getFileName

(

string

path

)

Definition at line 11 of file pathUtils.cpp.

                                {
    t_size split = path.lastIndexOfAnyChar(g_pathSeparators);
    if (split == ~0) return path;
    else return path.subString(split+1);
}

string pfc::io::path::getFileNameWithoutExtension

(

string

path

)

Definition at line 16 of file pathUtils.cpp.

                                                {
    string fn = getFileName(path);
    t_size split = fn.lastIndexOf('.');
    if (split == ~0) return fn;
    else return fn.subString(0,split);
}

string pfc::io::path::getIllegalNameChars

(

bool

allowWC

)

Definition at line 145 of file pathUtils.cpp.

                                         {
    return allowWC ? g_illegalNameChars_noWC : g_illegalNameChars;
}

string pfc::io::path::getParent

(

string

filePath

)

Definition at line 30 of file pathUtils.cpp.

                                  {
    t_size split = filePath.lastIndexOfAnyChar(g_pathSeparators);
    if (split == ~0) return "";
#ifdef _WINDOWS
    if (split > 0 && getIllegalNameChars().contains(filePath[split-1])) {
        if (split + 1 < filePath.length()) return filePath.subString(0,split+1);
        else return "";
    }
#endif
    return filePath.subString(0,split);
}

string pfc::io::path::getSeparators

(

)

Definition at line 56 of file pathUtils.cpp.

                       {
    return g_pathSeparators;
}

bool pfc::io::path::isDirectoryRoot

(

string

path

)

Definition at line 118 of file pathUtils.cpp.

                                  {
    return getParent(path).isEmpty();
}

static bool pfc::io::path::isIllegalTrailingChar ( char  c )

static

Definition at line 150 of file pathUtils.cpp.

                                          {
    return c == ' ' || c == '.';
}

bool pfc::io::path::isInsideDirectory	(	pfc::string	directory,
		pfc::string	inside
	)

Definition at line 109 of file pathUtils.cpp.

                                                              {
    //not very efficient
    string walk = inside;
    for(;;) {
        walk = getParent(walk);
        if (walk == "") return false;
        if (equals(directory,walk)) return true;
    }
}

bool pfc::io::path::isSeparator

(

char

c

)

Definition at line 53 of file pathUtils.cpp.

                         {
    return g_pathSeparators.indexOf(c) != ~0;
}

static string pfc::io::path::replaceIllegalChar ( char  c )

static

Definition at line 60 of file pathUtils.cpp.

                                         {
    switch(c) {
        case '*':
            return "x";
        case '\"':
            return "\'\'";
        case ':':
        case '/':
        case '\\':
            return "-";
        default:
            return "_";
    }
}

string pfc::io::path::replaceIllegalNameChars	(	string	fn,
		bool	allowWC
	)

Definition at line 93 of file pathUtils.cpp.

                                                        {
    const string illegal = getIllegalNameChars(allowWC);
    string_formatter output;
    for(t_size walk = 0; walk < fn.length(); ++walk) {
        const char c = fn[walk];
        if (string::isNonTextChar(c) || illegal.contains(c)) {
            string replacement = replaceIllegalChar(c);
            if (replacement.containsAnyChar(illegal)) /*per-OS weirdness security*/ replacement = "_";
            output << replacement.ptr();
        } else {
            output.add_byte(c);
        }
    }
    return output.toString();
}

string pfc::io::path::replaceIllegalPathChars

(

string

fn

)

Definition at line 74 of file pathUtils.cpp.

                                          {
    string illegal = getIllegalNameChars();
    string separators = getSeparators();
    string_formatter output;
    for(t_size walk = 0; walk < fn.length(); ++walk) {
        const char c = fn[walk];
        if (separators.contains(c)) {
            output.add_byte(getDefaultSeparator());
        } else if (string::isNonTextChar(c) || illegal.contains(c)) {
            string replacement = replaceIllegalChar(c);
            if (replacement.containsAnyChar(illegal)) /*per-OS weirdness security*/ replacement = "_";
            output << replacement.ptr();
        } else {
            output.add_byte(c);
        }
    }
    return output.toString();
}

string pfc::io::path::validateFileName	(	string	name,
		bool	allowWC
	)

Definition at line 155 of file pathUtils.cpp.

                                                   {
    for(t_size walk = 0; name[walk];) {
        if (name[walk] == '?') {
            t_size end = walk;
            do { ++end; } while(name[end] == '?');
            name = name.subString(0, walk) + name.subString(end);
        } else {
            ++walk;
        }
    }
#ifdef _WINDOWS
    name = replaceIllegalNameChars(name, allowWC);
    if (name.length() > 0) {
        t_size end = name.length();
        while(end > 0) {
            if (!isIllegalTrailingChar(name[end-1])) break;
            --end;
        }
        t_size begin = 0;
        while(begin < end) {
            if (!isIllegalTrailingChar(name[begin])) break;
            ++begin;
        }
        if (end < name.length() || begin > 0) name = name.subString(begin,end - begin);
    }
    if (name.isEmpty()) name = "_";
    return name;
#else
    return replaceIllegalNameChars(name);
#endif
}

Variable Documentation

const string pfc::io::path::g_pathSeparators("/") ( "\\/|"  )

static