NLMISC::CPath Class Reference

#include <path.h>

---

Detailed Description

Utility class for searching files in differents paths.

Warning:

addSearchPath(), clearMap() and remapExtension() are not reentrant.

all path and files are *case sensitive* on linux.

Author:

Vianney Lecroart

Nevrax France

Date:

2001

Definition at line 55 of file path.h.

Static Public Member Functions
void	addIgnoredDoubleFile (const std::string &ignoredFile)
void	addSearchBigFile (const std::string &filename, bool recurse, bool alternative, class NLMISC::IProgressCallback *progressCallBack=NULL)
void	addSearchFile (const std::string &file, bool remap=false, const std::string &virtual_ext="", class NLMISC::IProgressCallback *progressCallBack=NULL)
void	addSearchListFile (const std::string &filename, bool recurse, bool alternative)
void	addSearchPath (const std::string &path)
void	addSearchPath (const std::string &path, bool recurse, bool alternative, class IProgressCallback *progressCallBack=NULL)
void	clearMap ()
void	display ()
bool	exists (const std::string &filename)
std::string	getCurrentPath ()
void	getFileList (const std::string &extension, std::vector< std::string > &filenames)
std::string	getFullPath (const std::string &path, bool addFinalSlash=true)
void	getPathContent (const std::string &path, bool recurse, bool wantDir, bool wantFile, std::vector< std::string > &result, class IProgressCallback *progressCallBack=NULL, bool showEverything=false)
bool	isMemoryCompressed ()
void	loadRemappedFiles (const std::string &file)
std::string	lookup (const std::string &filename, bool throwException=true, bool displayWarning=true, bool lookupInLocalDirectory=true)
bool	makePathRelative (const char *basePath, std::string &relativePath)
void	memoryCompress ()
void	memoryUncompress ()
void	remapExtension (const std::string &ext1, const std::string &ext2, bool substitute)
void	remapFile (const std::string &file1, const std::string &file2)
void	removeAllAlternativeSearchPath ()
bool	setCurrentPath (const char *)
std::string	standardizeDosPath (const std::string &path)
std::string	standardizePath (const std::string &path, bool addFinalSlash=true)
Private Member Functions
	CPath ()
sint	findExtension (const std::string &ext1, const std::string &ext2)
Static Private Member Functions
CPath *	getInstance ()
void	insertFileInMap (const std::string &filename, const std::string &filepath, bool remap, const std::string &extension)
CMCFileEntry *	MCfind (const std::string &filename)
Private Attributes
char *	_AllFileNames
std::vector< std::string >	_AlternativePaths
std::vector< std::pair< std::string, std::string > >	_Extensions
	first ext1, second ext2 (ext1 could remplace ext2)
std::map< std::string, CFileEntry >	_Files
std::vector< CMCFileEntry >	_MCFiles
bool	_MemoryCompressed
std::map< std::string, std::string >	_RemappedFiles
std::vector< std::string >	IgnoredFiles
CStaticStringMapper	SSMext
CStaticStringMapper	SSMpath
Static Private Attributes
CPath *	_Instance = NULL

---

Constructor & Destructor Documentation

NLMISC::CPath::CPath (   )  [inline, private]

Definition at line 223 of file path.h. References _MemoryCompressed. { _MemoryCompressed = false; }

---

Member Function Documentation

void NLMISC::CPath::addIgnoredDoubleFile (  const std::string &  ignoredFile  )  [static]

If File in this list is added more than one in an addSearchPath, it doesn't launch a warning. Definition at line 1133 of file path.cpp. References uint. { NL_ALLOC_CONTEXT (MiPath); CPath::getInstance ()->IgnoredFiles.push_back(ignoredFile); }

void NLMISC::CPath::addSearchBigFile (  const std::string &  filename, bool  recurse, bool  alternative, class NLMISC::IProgressCallback *  progressCallBack = NULL )  [static]

Same as AddSearchPath but with a big file "c:/test.nbf" all files name contain in the big file will be included (the extention (Nel Big File) is used to know that it's a big file) Definition at line 1025 of file path.cpp. References nlwarning. 01026 { 01027 //#ifndef NL_OS_WINDOWS 01028 // nlerror( "BNP currently not supported on Unix" ); // test of BNP failed on Linux 01029 //#endif 01030 01031 // Check if filename is not empty 01032 if (sBigFilename.empty()) 01033 { 01034 nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): can't add empty file, skip it", sBigFilename.c_str(), recurse, alternative); 01035 return; 01036 } 01037 // Check if the file exists 01038 if (!CFile::isExists (sBigFilename)) 01039 { 01040 nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): '%s' is not found, skip it", sBigFilename.c_str(), recurse, alternative, sBigFilename.c_str()); 01041 return; 01042 } 01043 // Check if it s a file 01044 if (CFile::isDirectory (sBigFilename)) 01045 { 01046 nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): '%s' is not a file, skip it", sBigFilename.c_str(), recurse, alternative, sBigFilename.c_str()); 01047 return; 01048 } 01049 // Open and read the big file header 01050 CPath *inst = CPath::getInstance(); 01051 nlassert(!inst->_MemoryCompressed); 01052 01053 FILE *Handle = fopen (sBigFilename.c_str(), "rb"); 01054 if (Handle == NULL) 01055 { 01056 nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): can't open file, skip it", sBigFilename.c_str(), recurse, alternative); 01057 return; 01058 } 01059 01060 // add the link with the CBigFile singleton 01061 if (CBigFile::getInstance().add (sBigFilename, BF_ALWAYS_OPENED | BF_CACHE_FILE_ON_OPEN)) 01062 { 01063 // also add the bigfile name in the map to retreive the full path of a .bnp when we want modification date of the bnp for example 01064 insertFileInMap (CFile::getFilename (sBigFilename), sBigFilename, false, CFile::getExtension(sBigFilename)); 01065 01066 // parse the big file to add file in the map 01067 uint32 nFileSize=CFile::getFileSize (Handle); 01068 //nlfseek64 (Handle, 0, SEEK_END); 01069 //uint32 nFileSize = ftell (Handle); 01070 nlfseek64 (Handle, nFileSize-4, SEEK_SET); 01071 uint32 nOffsetFromBegining; 01072 fread (&nOffsetFromBegining, sizeof(uint32), 1, Handle); 01073 nlfseek64 (Handle, nOffsetFromBegining, SEEK_SET); 01074 uint32 nNbFile; 01075 fread (&nNbFile, sizeof(uint32), 1, Handle); 01076 for (uint32 i = 0; i < nNbFile; ++i) 01077 { 01078 // Progress bar 01079 if (progressCallBack) 01080 { 01081 progressCallBack->progress ((float)i/(float)nNbFile); 01082 progressCallBack->pushCropedValues ((float)i/(float)nNbFile, (float)(i+1)/(float)nNbFile); 01083 } 01084 01085 char FileName[256]; 01086 uint8 nStringSize; 01087 fread (&nStringSize, 1, 1, Handle); 01088 fread (FileName, 1, nStringSize, Handle); 01089 FileName[nStringSize] = 0; 01090 uint32 nFileSize2; 01091 fread (&nFileSize2, sizeof(uint32), 1, Handle); 01092 uint32 nFilePos; 01093 fread (&nFilePos, sizeof(uint32), 1, Handle); 01094 string sTmp = strlwr(string(FileName)); 01095 if (sTmp.empty()) 01096 { 01097 nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): can't add empty file, skip it", sBigFilename.c_str(), recurse, alternative); 01098 continue; 01099 } 01100 string bigfilenamealone = CFile::getFilename (sBigFilename); 01101 string filenamewoext = CFile::getFilenameWithoutExtension (sTmp); 01102 string ext = strlwr(CFile::getExtension(sTmp)); 01103 01104 insertFileInMap (sTmp, bigfilenamealone + "@" + sTmp, false, ext); for (uint j = 0; j < inst->_Extensions.size (); j++) { if (inst->_Extensions[j].first == ext) { // need to remap insertFileInMap (filenamewoext+"."+inst->_Extensions[j].second, 01105 bigfilenamealone + "@" + sTmp, true, inst->_Extensions[j].first); } } // Progress bar if (progressCallBack) { progressCallBack->popCropedValues (); } } } else { nlwarning ("PATH: CPath::addSearchBigFile(%s, %d, %d): can't add the big file", sBigFilename.c_str(), recurse, alternative); 01106 } 01107 01108 fclose (Handle); 01109 } 01110

void NLMISC::CPath::addSearchFile (  const std::string &  file, bool  remap = false, const std::string &  virtual_ext = "", class NLMISC::IProgressCallback *  progressCallBack = NULL )  [static]

Same as AddSearchPath but with a file "c:/autoexec.bat" this file only will included. wildwards *doesn't* work Definition at line 929 of file path.cpp. References file. { NL_ALLOC_CONTEXT (MiPath); CPath *inst = CPath::getInstance(); nlassert(!inst->_MemoryCompressed); string newFile = standardizePath(file, false); // check empty file if (newFile.empty()) { nlwarning ("PATH: CPath::addSearchFile(%s, %d, %s): can't add empty file, skip it", file.c_str(), remap, virtual_ext.c_str()); return; } // check if the file exists if (!CFile::isExists (newFile)) { nlwarning ("PATH: CPath::addSearchFile(%s, %d, %s): '%s' is not found, skip it", file.c_str(), remap, virtual_ext.c_str(), newFile.c_str()); return; } // check if it s a file if (CFile::isDirectory (newFile)) { nlwarning ("PATH: CPath::addSearchFile(%s, %d, %s): '%s' is not a file, skip it", file.c_str(), remap, virtual_ext.c_str(), newFile.c_str()); return; } // check if it s a big file if (CFile::getExtension(newFile) == "bnp") { NL_DISPLAY_PATH ("PATH: CPath::addSearchFile(%s, %d, %s): '%s' is a big file, add it", file.c_str(), remap, virtual_ext.c_str(), newFile.c_str()); addSearchBigFile(file, false, false, progressCallBack); return; } string filenamewoext = CFile::getFilenameWithoutExtension (newFile); string filename, ext; if (virtual_ext.empty()) { filename = CFile::getFilename (newFile); ext = CFile::getExtension (filename); } else { filename = filenamewoext + "." + virtual_ext; ext = CFile::getExtension (newFile); } insertFileInMap (filename, newFile, remap, ext); if (!remap && !ext.empty()) { // now, we have to see extension and insert in the map the remapped files for (uint i = 0; i < inst->_Extensions.size (); i++) { if (inst->_Extensions[i].first == strlwr(ext)) { // need to remap addSearchFile (newFile, true, inst->_Extensions[i].second, progressCallBack); } } } }

void NLMISC::CPath::addSearchListFile (  const std::string &  filename, bool  recurse, bool  alternative )  [static]

Same as AddSearchPath but with a path file "c:/test.pth" all files name contain in this file will be included (the extention is used to know that it's a path file) Definition at line 996 of file path.cpp. { NL_ALLOC_CONTEXT (MiPath); // check empty file if (filename.empty()) { nlwarning ("PATH: CPath::addSearchListFile(%s, %d, %d): can't add empty file, skip it", filename.c_str(), recurse, alternative); return; } // check if the file exists if (!CFile::isExists (filename)) { nlwarning ("PATH: CPath::addSearchListFile(%s, %d, %d): '%s' is not found, skip it", filename.c_str(), recurse, alternative, filename.c_str()); return; } // check if it s a file if (CFile::isDirectory (filename)) { nlwarning ("PATH: CPath::addSearchListFile(%s, %d, %d): '%s' is not a file, skip it", filename.c_str(), recurse, alternative, filename.c_str()); return; } // TODO lire le fichier et ajouter les fichiers qui sont dedans }

void NLMISC::CPath::addSearchPath (  const std::string &  path  )  [inline, static]

Used only for compatibility with the old CPath. In this case, we don't use the map to have the same behavior as the old CPath Definition at line 78 of file path.h. References addSearchPath(). { addSearchPath (path, false, true, NULL); }

void NLMISC::CPath::addSearchPath (  const std::string &  path, bool  recurse, bool  alternative, class IProgressCallback *  progressCallBack = NULL )  [static]

Adds a search path. The path is a directory "c:/temp" all files in the directory will be included (and recursively if asked) Alternative directories are not precached (instead of non Alternative files) and will used when a file is not found in the standard directories. For example, local data will be in the cached directories and server repository files will be in the Alternative files. If a new file is not found in the local data, we'll try to find it on the repositrory. When Alternative is false, all added file names must be uniq or a warning will be display. In the Alternative directories, it could have more than one file with the same name. Warning: the path you provide is case sensitive, you must be sure that the path name is exactly the same Parameters: path  the path name. The separator for directories could be '/' or '\' (bit '\' will be translate into '/' in the function). recurse  true if you want the function recurse in sub-directories. Alternative  true if you want to add the path in the Alternative directories. progressCallBack  is a progression callback interface pointer. Definition at line 807 of file path.cpp. Referenced by addSearchPath(). { NL_ALLOC_CONTEXT (MiPath); H_AUTO_INST(addSearchPath); CPath *inst = CPath::getInstance(); nlassert(!inst->_MemoryCompressed); // check empty directory if (path.empty()) { nlwarning ("PATH: CPath::addSearchPath(%s, %d, %d): can't add empty directory, skip it", path.c_str(), recurse, alternative); return; } // check if it s a directory if (!CFile::isDirectory (path)) { nlinfo ("PATH: CPath::addSearchPath(%s, %d, %d): '%s' is not a directory, I'll call addSearchFile()", path.c_str(), recurse, alternative, path.c_str()); addSearchFile (path, false, "", progressCallBack); return; } string newPath = standardizePath(path); // check if it s a directory if (!CFile::isExists (newPath)) { nlwarning ("PATH: CPath::addSearchPath(%s, %d, %d): '%s' is not found, skip it", path.c_str(), recurse, alternative, newPath.c_str()); return; } nlinfo ("PATH: CPath::addSearchPath(%s, %d, %d): adding the path '%s'", path.c_str(), recurse, alternative, newPath.c_str()); NL_DISPLAY_PATH("PATH: CPath::addSearchPath(%s, %d, %d): try to add '%s'", path.c_str(), recurse, alternative, newPath.c_str()); if (alternative) { vector<string> pathsToProcess; // add the current path pathsToProcess.push_back (newPath); if (recurse) { // find all path and subpath getPathContent (newPath, recurse, true, false, pathsToProcess, progressCallBack); } for (uint p = 0; p < pathsToProcess.size(); p++) { // check if the path not already in the vector uint i; for (i = 0; i < inst->_AlternativePaths.size(); i++) { if (inst->_AlternativePaths[i] == pathsToProcess[p]) break; } if (i == inst->_AlternativePaths.size()) { // add them in the alternative directory inst->_AlternativePaths.push_back (pathsToProcess[p]); NL_DISPLAY_PATH("PATH: CPath::addSearchPath(%s, %d, %d): path '%s' added", newPath.c_str(), recurse, alternative, pathsToProcess[p].c_str()); } else { nlwarning ("PATH: CPath::addSearchPath(%s, %d, %d): path '%s' already added", newPath.c_str(), recurse, alternative, pathsToProcess[p].c_str()); } } } else { vector<string> filesToProcess; // Progree bar if (progressCallBack) { progressCallBack->progress (0); progressCallBack->pushCropedValues (0, 0.5f); } // find all files in the path and subpaths getPathContent (newPath, recurse, false, true, filesToProcess, progressCallBack); // Progree bar if (progressCallBack) { progressCallBack->popCropedValues (); progressCallBack->progress (0.5); progressCallBack->pushCropedValues (0.5f, 1); } // add them in the map for (uint f = 0; f < filesToProcess.size(); f++) { // Progree bar if (progressCallBack) { progressCallBack->progress ((float)f/(float)filesToProcess.size()); progressCallBack->pushCropedValues ((float)f/(float)filesToProcess.size(), (float)(f+1)/(float)filesToProcess.size()); } string filename = CFile::getFilename (filesToProcess[f]); string filepath = CFile::getPath (filesToProcess[f]); // insertFileInMap (filename, filepath, false, CFile::getExtension(filename)); addSearchFile (filesToProcess[f], false, "", progressCallBack); // Progree bar if (progressCallBack) { progressCallBack->popCropedValues (); } } // Progree bar if (progressCallBack) { progressCallBack->popCropedValues (); } } }

void NLMISC::CPath::clearMap (   )  [static]

Clears the map that contains all cached files (Use this function to take into account new files). Definition at line 153 of file path.cpp. References _Files, _MemoryCompressed, NL_DISPLAY_PATH, and nlassert. { CPath *inst = CPath::getInstance(); nlassert(!inst->_MemoryCompressed); inst->_Files.clear (); CBigFile::getInstance().removeAll (); NL_DISPLAY_PATH("PATH: CPath::clearMap(): map directory cleared"); }

void NLMISC::CPath::display (   )  [static]

Definition at line 1195 of file path.cpp. { CPath *inst = CPath::getInstance (); nlinfo ("PATH: Contents of the map:"); nlinfo ("PATH: %-25s %-5s %-5s %s", "filename", "ext", "remap", "full path"); nlinfo ("PATH: ----------------------------------------------------"); if (inst->_MemoryCompressed) { for (uint i = 0; i < inst->_MCFiles.size(); ++i) { const CMCFileEntry &fe = inst->_MCFiles[i]; string ext = inst->SSMext.get(fe.idExt); string path = inst->SSMpath.get(fe.idPath); nlinfo ("PATH: %-25s %-5s %-5d %s", fe.Name, ext.c_str(), fe.Remapped, path.c_str()); } } else { for (map<string, CFileEntry>::iterator it = inst->_Files.begin(); it != inst->_Files.end (); it++) { string ext = inst->SSMext.get((*it).second.idExt); string path = inst->SSMpath.get((*it).second.idPath); nlinfo ("PATH: %-25s %-5s %-5d %s", (*it).first.c_str(), ext.c_str(), (*it).second.Remapped, path.c_str()); } } nlinfo ("PATH: "); nlinfo ("PATH: Contents of the alternative directory:"); for (uint i = 0; i < inst->_AlternativePaths.size(); i++) { nlinfo ("PATH: '%s'", inst->_AlternativePaths[i].c_str ()); } nlinfo ("PATH: "); nlinfo ("PATH: Contents of the remapped entension table:"); for (uint j = 0; j < inst->_Extensions.size(); j++) { nlinfo ("PATH: '%s' -> '%s'", inst->_Extensions[j].first.c_str (), inst->_Extensions[j].second.c_str ()); } nlinfo ("PATH: End of display"); }

bool NLMISC::CPath::exists (  const std::string &  filename  )  [static]

Return if a file is present in the lookup map. The function changes filename into lower case and removes ended spaces before searching. Warning: This function checks *only* in the map, not in local dir or alternative dir Parameters: filename  the file name you are seeking. (ex: "test.txt") lookupInLocalDirectory  if true, the lookup() will first try to open the file without path. Returns: true if the filename exists in the map used by lookup to know where the file is, false otherwise Definition at line 421 of file path.cpp. { // Try to find in the map directories CPath *inst = CPath::getInstance(); string str = strlwr(filename); // Remove end spaces while ((!str.empty()) && (str[str.size()-1] == ' ')) { str.resize (str.size()-1); } if (inst->_MemoryCompressed) { CMCFileEntry *pMCFE = MCfind(str); // If found in the vector, returns it if (pMCFE != NULL) return true; } else { map<string, CFileEntry>::iterator it = inst->_Files.find (str); // If found in the map, returns it if (it != inst->_Files.end()) return true; } return false; }

sint NLMISC::CPath::findExtension (  const std::string &  ext1, const std::string &  ext2 )  [private]

Definition at line 177 of file path.cpp. References _Extensions, sint, and uint. Referenced by remapExtension(). { CPath *inst = CPath::getInstance(); for (uint i = 0; i < inst->_Extensions.size (); i++) { if (inst->_Extensions[i].first == ext1 && inst->_Extensions[i].second == ext2) { return i; } } return -1; }

std::string NLMISC::CPath::getCurrentPath (   )  [static]

Returns the current path of the applicated. Definition at line 504 of file path.cpp. References buffer. { char buffer [10000]; #ifdef NL_OS_WINDOWS return standardizePath(_getcwd(buffer, 10000), false); #else return standardizePath(getcwd(buffer, 10000), false); #endif }

void NLMISC::CPath::getFileList (  const std::string &  extension, std::vector< std::string > &  filenames )  [static]

Create a list of file having the requested extension. Definition at line 87 of file path.cpp. References _Files, _MCFiles, _MemoryCompressed, NLMISC::CStaticStringMapper::get(), getInstance(), and SSMext. Referenced by loadForm(). { CPath *inst = getInstance(); if (!inst->_MemoryCompressed) { std::map<std::string, CFileEntry>::iterator first(inst->_Files.begin()), last(inst->_Files.end()); if( !extension.empty() ) { for (; first != last; ++ first) { string ext = inst->SSMext.get(first->second.idExt); if (ext == extension) { filenames.push_back(first->first); } } } // if extension is empty we keep all files else { for (; first != last; ++ first) { filenames.push_back(first->first); } } } else { // compressed memory version std::vector<CPath::CMCFileEntry>::iterator first(inst->_MCFiles.begin()), last(inst->_MCFiles.end()); if( !extension.empty() ) { for (; first != last; ++ first) { string ext = inst->SSMext.get(first->idExt); if (ext == extension) { filenames.push_back(first->Name); } } } // if extension is empty we keep all files else { for (; first != last; ++ first) { filenames.push_back(first->Name); } } } }

std::string NLMISC::CPath::getFullPath (  const std::string &  path, bool  addFinalSlash = true )  [static]

Get the full path based on a file/path and the current directory. Example, imagine that the current path is c: and toto is a directory getFullPath ("toto") returns "c:/temp/toto/" getFullPath ("../toto") returns "c:/temp/../toto/" getFullPath ("d:\dir\toto") returns "d:/dir/toto/" getFullPath ("\toto") returns "c:/toto/" getFullPath ("") returns "c:/temp/" Parameters: path  the path Returns: the full path Definition at line 525 of file path.cpp. Referenced by NLMISC::CConfigFile::reparse(). { string currentPath = standardizePath (getCurrentPath ()); string sPath = standardizePath (path, addFinalSlash); // current path if (path.empty() || sPath == "." || sPath == "./") { return currentPath; } // windows full path if (path.size() >= 2 && path[1] == ':') { return sPath; } if (path.size() >= 2 && (path[0] == '/' || path[0] == '\\') && (path[1] == '/' || path[1] == '\\')) { return sPath; } // from root if (path [0] == '/' || path[0] == '\\') { if (currentPath.size() > 2 && currentPath[1] == ':') { return currentPath.substr(0,3) + sPath.substr(1); } else { return sPath; } } // default case return currentPath + sPath; }

CPath * NLMISC::CPath::getInstance (   )  [static, private]

Definition at line 142 of file path.cpp. Referenced by getFileList(), and isMemoryCompressed(). { if (_Instance == NULL) { #undef new _Instance = new CPath; #define new NL_NEW } return _Instance; }

void NLMISC::CPath::getPathContent (  const std::string &  path, bool  recurse, bool  wantDir, bool  wantFile, std::vector< std::string > &  result, class IProgressCallback *  progressCallBack = NULL, bool  showEverything = false )  [static]

List all files in a directory. Parameters: path  path where files are scanned. No-op if empty recurse  true if want to recurs directories wantDir  true if want to add directorires in result wantFile  true if want to add files in result result  list of string where directories/files names are added. progressCallBack  is a progression callback interface pointer. showEverything  false skips *.log files and CVS directories Definition at line 688 of file path.cpp. References NL_DISPLAY_PATH. Referenced by NL3D::CAnimationSet::loadFromFiles(). { if( path.empty() ) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(): Empty input Path"); return; } #ifndef NL_OS_WINDOWS BasePathgetPathContent = CPath::standardizePath (path); #endif DIR *dir = opendir (path.c_str()); if (dir == NULL) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): could not open the directory", path.c_str(), recurse, wantDir, wantFile); return; } // contains path that we have to recurs into vector<string> recursPath; while (true) { dirent *de = readdir(dir); if (de == NULL) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): end of directory", path.c_str(), recurse, wantDir, wantFile); break; } string fn = getname (de); // skip . and .. if (fn == "." || fn == "..") continue; if (isdirectory(de)) { // skip CVS directory if ((!showEverything) && (fn == "CVS")) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): skip CVS directory", path.c_str(), recurse, wantDir, wantFile); continue; } string stdName = standardizePath(standardizePath(path) + fn); if (recurse) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): need to recurse into '%s'", path.c_str(), recurse, wantDir, wantFile, stdName.c_str()); recursPath.push_back (stdName); } if (wantDir) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): adding path '%s'", path.c_str(), recurse, wantDir, wantFile, stdName.c_str()); result.push_back (stdName); } } if (wantFile && isfile(de)) { if ( (!showEverything) && (fn.size() >= 4 && fn.substr (fn.size()-4) == ".log")) { NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): skip *.log files (%s)", path.c_str(), recurse, wantDir, wantFile, fn.c_str()); continue; } /* int lastSep = CFile::getLastSeparator(path); #ifdef NL_OS_WINDOWS char sep = lastSep == std::string::npos ? '\\' : path[lastSep]; #else char sep = lastSep == std::string::npos ? '/' : path[lastSep]; #endif */ string stdName = standardizePath(path) + getname(de); NL_DISPLAY_PATH("PATH: CPath::getPathContent(%s, %d, %d, %d): adding file '%s'", path.c_str(), recurse, wantDir, wantFile, stdName.c_str()); result.push_back (stdName); } } closedir (dir); #ifndef NL_OS_WINDOWS BasePathgetPathContent = ""; #endif // let s recurse for (uint i = 0; i < recursPath.size (); i++) { // Progress bar if (progressCallBack) { progressCallBack->progress ((float)i/(float)recursPath.size ()); progressCallBack->pushCropedValues ((float)i/(float)recursPath.size (), (float)(i+1)/(float)recursPath.size ()); } getPathContent (recursPath[i], recurse, wantDir, wantFile, result, progressCallBack); // Progress bar if (progressCallBack) { progressCallBack->popCropedValues (); } } }

void NLMISC::CPath::insertFileInMap (  const std::string &  filename, const std::string &  filepath, bool  remap, const std::string &  extension )  [static, private]

Definition at line 1139 of file path.cpp. Referenced by remapExtension(). 01140 { 01141 NL_ALLOC_CONTEXT (MiPath); 01142 CPath *inst = CPath::getInstance(); 01143 nlassert(!inst->_MemoryCompressed); 01144 // find if the file already exist 01145 map<string, CFileEntry>::iterator it = inst->_Files.find (strlwr(filename)); 01146 if (it != inst->_Files.end ()) 01147 { 01148 string path = inst->SSMpath.get((*it).second.idPath); 01149 if (path.find("@") != string::npos && filepath.find("@") == string::npos) { // if there's a file in a big file and a file in a path, the file in path wins // replace with the new one nlinfo ("PATH: CPath::insertFileInMap(%s, %s, %d, %s): already inserted from '%s' but special case so overide it", filename.c_str(), filepath.c_str(), remap, extension.c_str(), path.c_str()); 01150 string sTmp = filepath.substr(0,filepath.rfind('/')+1); 01151 (*it).second.idPath = inst->SSMpath.add(sTmp); 01152 (*it).second.Remapped = remap; 01153 (*it).second.idExt = inst->SSMext.add(extension); 01154 (*it).second.Name = filename; 01155 } 01156 else 01157 { 01158 for(uint i = 0; i < inst->IgnoredFiles.size(); i++) 01159 { 01160 // if we don't want to display a warning, skip it 01161 if(filename == inst->IgnoredFiles[i]) 01162 return; 01163 } 01164 // if the path is the same, don't warn 01165 string path2 = inst->SSMpath.get((*it).second.idPath); 01166 string sPathOnly = filepath.substr(0,filepath.rfind('@')+1); 01167 if (path2 == sPathOnly) 01168 return; 01169 nlwarning ("PATH: CPath::insertFileInMap(%s, %s, %d, %s): already inserted from '%s', skip it", filename.c_str(), filepath.c_str(), remap, extension.c_str(), path2.c_str()); 01170 } 01171 } 01172 else 01173 { 01174 CFileEntry fe; 01175 fe.idExt = inst->SSMext.add(extension); 01176 fe.Remapped = remap; 01177 string sTmp; 01178 if (filepath.find("@") == string::npos) sTmp = filepath.substr(0,filepath.rfind('/')+1); else sTmp = filepath.substr(0,filepath.rfind('@')+1); fe.idPath = inst->SSMpath.add(sTmp); fe.Name = filename; inst->_Files.insert (make_pair(strlwr(filename), fe)); NL_DISPLAY_PATH("PATH: CPath::insertFileInMap(%s, %s, %d, %s): added", strlwr(filename).c_str(), filepath.c_str(), remap, strlwr(extension).c_str()); 01179 } 01180 } 01181

bool NLMISC::CPath::isMemoryCompressed (   )  [inline, static]

Definition at line 215 of file path.h. References _MemoryCompressed, and getInstance(). { return getInstance()->_MemoryCompressed; }

void NLMISC::CPath::loadRemappedFiles (  const std::string &  file  )  [static]

Load a file containing the remapped file (you must have done addsearchpath, this method use lookup) Format is remapped_name_file, real_file separators are , and Definition at line 293 of file path.cpp. References NLMISC::CIFile::eof(), file, NLMISC::CIFile::getline(), lookup(), NLMISC::CIFile::open(), remapFile(), NLMISC::removeAllUnusedChar(), and NLMISC::CIFile::setCacheFileOnOpen(). { NL_ALLOC_CONTEXT (MiPath); string fullName = lookup(file, false, true, true); CIFile f; f.setCacheFileOnOpen (true); if (!f.open (fullName)) return; char sTmp[514]; string str; while (!f.eof()) { f.getline(sTmp, 512); str = sTmp; if (str.find(',')) { removeAllUnusedChar(str); if (!str.empty()) remapFile( str.substr(0,str.find(',')), str.substr(str.find(',')+1, str.size()) ); } } }

string NLMISC::CPath::lookup (  const std::string &  filename, bool  throwException = true, bool  displayWarning = true, bool  lookupInLocalDirectory = true )  [static]

Returns the long name (path + filename) for the specified file. The directory separator is always '/'. First, the lookup() lookups in standard directories (Alternative=false). If not found, it lookups in the Alternative directories. If not found the lookup() returns empty string "" (and generate an exception if throwException is true) The filename is not case sensitive so if the real filename is "FooBAR.Jpg" and you call lookup("fOOBar.jPg"), it'll return the real filename "FooBAR.Jpg" Parameters: filename  the file name you are seeking. (ex: "test.txt") throwException  used for backward compatibility, set to true to generate an EPathNotFound. displayWarning  set to false if you don't want the function displays a warning if the file is not found lookupInLocalDirectory  if true, the lookup() will first try to open the file without path. Returns: empty string if file is not found or the full path + file name (ex: "c:/temp/test.txt"); Definition at line 320 of file path.cpp. Referenced by NL3D::CAnimationSetUser::addAnimation(), NLSOUND::CAudioMixerUser::init(), loadForm(), loadRemappedFiles(), and NLPACS::CRetrieverBank::serial(). 00321 { 00322 // If the file already contains a @, it means that a lookup already proceed and returning a big file, do nothing 00323 if (filename.find ("@") != string::npos) { NL_DISPLAY_PATH("PATH: CPath::lookup(%s): already found", filename.c_str()); 00324 return filename; 00325 } 00326 00327 // Try to find in the map directories 00328 CPath *inst = CPath::getInstance(); 00329 string str = strlwr(filename); 00330 00331 // Remove end spaces 00332 while ((!str.empty()) && (str[str.size()-1] == ' ')) 00333 { 00334 str.resize (str.size()-1); 00335 } 00336 00337 map<string, string>::iterator itss = inst->_RemappedFiles.find(str); 00338 if (itss != inst->_RemappedFiles.end()) 00339 str = itss->second; 00340 00341 if (inst->_MemoryCompressed) 00342 { 00343 CMCFileEntry *pMCFE = MCfind(str); 00344 // If found in the map, returns it 00345 if (pMCFE != NULL) 00346 { 00347 string fname, path = inst->SSMpath.get(pMCFE->idPath); 00348 if (pMCFE->Remapped) 00349 fname = CFile::getFilenameWithoutExtension(pMCFE->Name) + "." + inst->SSMext.get(pMCFE->idExt); 00350 else 00351 fname = pMCFE->Name; 00352 00353 NL_DISPLAY_PATH("PATH: CPath::lookup(%s): found in the map directory: '%s'", fname.c_str(), path.c_str()); 00354 return path + fname; 00355 } 00356 } 00357 else // NOT memory compressed 00358 { 00359 map<string, CFileEntry>::iterator it = inst->_Files.find (str); 00360 // If found in the map, returns it 00361 if (it != inst->_Files.end()) 00362 { 00363 string fname, path = inst->SSMpath.get((*it).second.idPath); 00364 if (it->second.Remapped) 00365 fname = CFile::getFilenameWithoutExtension((*it).second.Name) + "." + inst->SSMext.get((*it).second.idExt); 00366 else 00367 fname = (*it).second.Name; 00368 00369 NL_DISPLAY_PATH("PATH: CPath::lookup(%s): found in the map directory: '%s'", fname.c_str(), path.c_str()); 00370 return path + fname; 00371 } 00372 } 00373 00374 00375 // Try to find in the alternative directories 00376 for (uint i = 0; i < inst->_AlternativePaths.size(); i++) 00377 { 00378 string s = inst->_AlternativePaths[i] + filename; 00379 if ( CFile::fileExists(s) ) 00380 { 00381 NL_DISPLAY_PATH("PATH: CPath::lookup(%s): found in the alternative directory: '%s'", filename.c_str(), s.c_str()); 00382 return s; 00383 } 00384 00385 // try with the remapping 00386 for (uint j = 0; j < inst->_Extensions.size(); j++) 00387 { 00388 if (strlwr(CFile::getExtension (filename)) == inst->_Extensions[j].second) 00389 { 00390 string rs = inst->_AlternativePaths[i] + CFile::getFilenameWithoutExtension (filename) + "." + inst->_Extensions[j].first; 00391 if ( CFile::fileExists(rs) ) 00392 { 00393 NL_DISPLAY_PATH("PATH: CPath::lookup(%s): found in the alternative directory: '%s'", filename.c_str(), rs.c_str()); 00394 return rs; 00395 } 00396 } 00397 } 00398 } 00399 00400 // Try to find in the current directory 00401 if ( lookupInLocalDirectory && CFile::fileExists(filename) ) 00402 { 00403 NL_DISPLAY_PATH("PATH: CPath::lookup(%s): found in the current directory: '%s'", filename.c_str(), filename.c_str()); 00404 return filename; 00405 } 00406 00407 // Not found 00408 if (displayWarning) 00409 { 00410 nlwarning ("PATH: CPath::lookup(%s): file not found", filename.c_str()); 00411 } 00412 00413 if (throwException) 00414 throw EPathNotFound (filename); 00415 00416 return ""; 00417 } 00418

bool NLMISC::CPath::makePathRelative (  const char *  basePath, std::string &  relativePath )  [static]

Make a path relative to another if possible, else doesn't change it. Parameters: basePath  is the base path to be relative to. relativePath  is the path to make relative to basePath. return true if relativePath as been done relative to basePath, false is relativePath has not been changed. Definition at line 1674 of file path.cpp. { // Standard path with final slash string tmp = standardizePath (basePath, true); string src = standardizePath (relativePath, true); string prefix; while (1) { // Compare with relativePath if (strncmp (tmp.c_str (), src.c_str (), tmp.length ()) == 0) { // Troncate uint size = tmp.length (); // Same path ? if (size == src.length ()) { relativePath = "."; return true; } relativePath = prefix+relativePath.substr (size, relativePath.length () - size); return true; } // Too small ? if (tmp.length ()<2) break; // Remove last directory uint lastPos = tmp.rfind ('/', tmp.length ()-2); uint previousPos = tmp.find ('/'); if ((lastPos == previousPos) || (lastPos == string::npos)) break; // Troncate tmp = tmp.substr (0, lastPos+1); // New prefix prefix += "../"; } return false; }

CPath::CMCFileEntry * NLMISC::CPath::MCfind (  const std::string &  filename  )  [static, private]

Definition at line 162 of file path.cpp. References _MCFiles, _MemoryCompressed, nlassert, and NLMISC::CPath::CMCFileComp::specialCompare(). { CPath *inst = CPath::getInstance(); nlassert(inst->_MemoryCompressed); vector<CMCFileEntry>::iterator it; it = lower_bound(inst->_MCFiles.begin(), inst->_MCFiles.end(), filename.c_str(), CMCFileComp()); if (it != inst->_MCFiles.end()) { CMCFileComp FileComp; if (FileComp.specialCompare(*it, filename.c_str()) == 0) return &(*it); } return NULL; }

void NLMISC::CPath::memoryCompress (   )  [static]

For the moment after memoryCompress you cant addsearchpath anymore Definition at line 1235 of file path.cpp. References _AllFileNames, _MCFiles, NLMISC::CStaticStringMapper::get(), NLMISC::CPath::CFileEntry::idExt, NLMISC::CPath::CFileEntry::idPath, NLMISC::CPath::CFileEntry::Name, nlassert, NLMISC::CPath::CFileEntry::Remapped, and SSMpath. { NL_ALLOC_CONTEXT (MiPath); CPath *inst = CPath::getInstance(); inst->SSMext.memoryCompress(); inst->SSMpath.memoryCompress(); uint nDbg = inst->_Files.size(); nlinfo ("PATH: Number of file : %d", nDbg); nDbg = inst->SSMext.getCount(); nlinfo ("PATH: Number of different extension : %d", nDbg); nDbg = inst->SSMpath.getCount(); nlinfo ("PATH: Number of different path : %d", nDbg); // Convert from _Files to _MCFiles uint nSize = 0, nNb = 0; map<string,CFileEntry>::iterator it = inst->_Files.begin(); while (it != inst->_Files.end()) { string sTmp = inst->SSMpath.get(it->second.idPath); if ((sTmp.find('@') != string::npos) && !it->second.Remapped) { // This is a file included in a bigfile (so the name is in the bigfile manager) } else { nSize += it->second.Name.size() + 1; } nNb++; it++; } inst->_AllFileNames = new char[nSize]; memset(inst->_AllFileNames, 0, nSize); inst->_MCFiles.resize(nNb); it = inst->_Files.begin(); nSize = 0; nNb = 0; while (it != inst->_Files.end()) { CFileEntry &rFE = it->second; string sTmp = inst->SSMpath.get(rFE.idPath); if ((sTmp.find('@') != string::npos) && !rFE.Remapped) { // This is a file included in a bigfile (so the name is in the bigfile manager) sTmp = sTmp.substr(0, sTmp.size()-1); inst->_MCFiles[nNb].Name = CBigFile::getInstance().getFileNamePtr(rFE.Name, sTmp); nlassert(inst->_MCFiles[nNb].Name != NULL); } else { strcpy(inst->_AllFileNames+nSize, rFE.Name.c_str()); inst->_MCFiles[nNb].Name = inst->_AllFileNames+nSize; nSize += rFE.Name.size() + 1; } inst->_MCFiles[nNb].idExt = rFE.idExt; inst->_MCFiles[nNb].idPath = rFE.idPath; inst->_MCFiles[nNb].Remapped = rFE.Remapped; nNb++; it++; } contReset(inst->_Files); inst->_MemoryCompressed = true; }

void NLMISC::CPath::memoryUncompress (   )  [static]

Definition at line 1304 of file path.cpp. References uint32. { CPath *inst = CPath::getInstance (); inst->SSMext.memoryUncompress(); inst->SSMpath.memoryUncompress(); inst->_MemoryCompressed = false; }

void NLMISC::CPath::remapExtension (  const std::string &  ext1, const std::string &  ext2, bool  substitute )  [static]

Add a remapping function to allow file extension substitution. eg remapExtension("dds", "tga", true) Where the boolean indicates whether the "dds" should replace a "tga" if one exists - again - a warning should be generated if the two are present. ie: If you have a file called pic.dds and you call remapExtension("dds", "tga", true), if you call lookup("pic.tga"), it'll return "pic.dds" Definition at line 190 of file path.cpp. References _Extensions, _Files, _MemoryCompressed, file, findExtension(), NLMISC::CStaticStringMapper::get(), insertFileInMap(), NL_DISPLAY_PATH, nlassert, nlwarning, sint, SSMext, SSMpath, NLMISC::strlwr(), and uint32. { NL_ALLOC_CONTEXT (MiPath); CPath *inst = CPath::getInstance(); nlassert(!inst->_MemoryCompressed); string ext1lwr = strlwr (ext1); string ext2lwr = strlwr (ext2); if (ext1lwr.empty() || ext2lwr.empty()) { nlwarning ("PATH: CPath::remapExtension(%s, %s, %d): can't remap empty extension", ext1lwr.c_str(), ext2lwr.c_str(), substitute); } if (ext1lwr == "bnp" || ext2lwr == "bnp") { nlwarning ("PATH: CPath::remapExtension(%s, %s, %d): you can't remap a big file", ext1lwr.c_str(), ext2lwr.c_str(), substitute); } if (!substitute) { // remove the mapping from the mapping list sint n = inst->findExtension (ext1lwr, ext2lwr); nlassert (n != -1); inst->_Extensions.erase (inst->_Extensions.begin() + n); // remove mapping in the map map<string, CFileEntry>::iterator it = inst->_Files.begin(); map<string, CFileEntry>::iterator nit = it; while (it != inst->_Files.end ()) { nit++; string ext = inst->SSMext.get((*it).second.idExt); if ((*it).second.Remapped && ext == ext2lwr) { inst->_Files.erase (it); } it = nit; } NL_DISPLAY_PATH("PATH: CPath::remapExtension(%s, %s, %d): extension removed", ext1lwr.c_str(), ext2lwr.c_str(), substitute); } else { sint n = inst->findExtension (ext1lwr, ext2lwr); if (n != -1) { nlwarning ("PATH: CPath::remapExtension(%s, %s, %d): remapping already set", ext1lwr.c_str(), ext2lwr.c_str(), substitute); return; } // adding mapping into the mapping list inst->_Extensions.push_back (make_pair (ext1lwr, ext2lwr)); // adding mapping into the map vector<string> newFiles; map<string, CFileEntry>::iterator it = inst->_Files.begin(); while (it != inst->_Files.end ()) { string ext = inst->SSMext.get((*it).second.idExt); if (!(*it).second.Remapped && ext == ext1lwr) { // find if already exist uint32 pos = (*it).first.find_last_of ("."); if (pos != string::npos) { string file = (*it).first.substr (0, pos + 1); file += ext2lwr; // TODO perhaps a problem because I insert in the current map that i parcours string path = inst->SSMpath.get((*it).second.idPath); insertFileInMap (file, path+file, true, ext1lwr); } } it++; } NL_DISPLAY_PATH("PATH: CPath::remapExtension(%s, %s, %d): extension added", ext1lwr.c_str(), ext2lwr.c_str(), substitute); } }

void NLMISC::CPath::remapFile (  const std::string &  file1, const std::string &  file2 )  [static]

Add file remapping ie: If you have a file called pic.dds, and call remapFile("picture.dds", "pic.dds") calling lookup("picture.dds") will in fact call lookup("pic.dds") Definition at line 270 of file path.cpp. References _RemappedFiles, and NLMISC::strlwr(). Referenced by loadRemappedFiles(). { NL_ALLOC_CONTEXT (MiPath); CPath *inst = CPath::getInstance(); if (file1.empty()) return; if (file2.empty()) return; inst->_RemappedFiles[strlwr(file1)] = strlwr(file2); }

void NLMISC::CPath::removeAllAlternativeSearchPath (   )  [static]

Remove all search path contains in the alternative directories Definition at line 799 of file path.cpp. { CPath *inst = CPath::getInstance(); inst->_AlternativePaths.clear (); NL_DISPLAY_PATH("PATH: CPath::RemoveAllAternativeSearchPath(): removed"); }

bool NLMISC::CPath::setCurrentPath (  const char *   )  [static]

Set the current path of the applicated. Definition at line 515 of file path.cpp. { #ifdef NL_OS_WINDOWS return _chdir(newDir) == 0; #else // todo : check this compiles under linux. Thanks (Hulud) return chdir(newDir) == 0; #endif }

std::string NLMISC::CPath::standardizeDosPath (  const std::string &  path  )  [static]

Remplace / with \ for fucking dos process. Use only this function if can't do another way. For exemple, if you do a system("copy data/toto data/tata"); it'll not work because dos doesn't understand /. But in the majority of case, / working (it works for fopen for example) Definition at line 482 of file path.cpp. References uint. { string newPath; for (uint i = 0; i < path.size(); i++) { if (path[i] == '/') newPath += '\\'; // Yoyo: supress toLower. Not usefull!?! /*else if (isupper(path[i])) newPath += tolower(path[i]);*/ else newPath += path[i]; } if (CFile::isExists(path) && CFile::isDirectory(path) && newPath[newPath.size()-1] != '\\') newPath += '\\'; return newPath; }

string NLMISC::CPath::standardizePath (  const std::string &  path, bool  addFinalSlash = true )  [static]

Take a path and put it in the portable format and add a terminated / if needed ie: "C:\\Game/dir1" will become "C:/Game/dir1/" or "C:/Game/dir1" if addFinalSlash is false Definition at line 452 of file path.cpp. References uint. Referenced by NLMISC::CConfigFile::reparse(). { string newPath; // check empty path if (path.empty()) return ""; // don't transform the first \\ for windows network path // if (path.size() >= 2 && path[0] == '\\' && path[1] == '\\') // { // newPath += "\\\\"; // i = 2; // } for (uint i = 0; i < path.size(); i++) { // don't transform the first \\ for windows network path if (path[i] == '\\') newPath += '/'; else newPath += path[i]; } // add terminal slash if (addFinalSlash && newPath[path.size()-1] != '/') newPath += '/'; return newPath; }

---

Field Documentation

char* NLMISC::CPath::_AllFileNames [private]

Definition at line 267 of file path.h. Referenced by memoryCompress().

std::vector<std::string> NLMISC::CPath::_AlternativePaths [private]

Definition at line 229 of file path.h.

std::vector<std::pair<std::string, std::string> > NLMISC::CPath::_Extensions [private]

first ext1, second ext2 (ext1 could remplace ext2) Definition at line 302 of file path.h. Referenced by findExtension(), and remapExtension().

std::map<std::string, CFileEntry> NLMISC::CPath::_Files [private]

Definition at line 254 of file path.h. Referenced by clearMap(), getFileList(), and remapExtension().

CPath * NLMISC::CPath::_Instance = NULL [static, private]

Definition at line 80 of file path.cpp.

std::vector<CMCFileEntry> NLMISC::CPath::_MCFiles [private]

Definition at line 270 of file path.h. Referenced by getFileList(), MCfind(), and memoryCompress().

bool NLMISC::CPath::_MemoryCompressed [private]

Definition at line 239 of file path.h. Referenced by clearMap(), CPath(), getFileList(), isMemoryCompressed(), MCfind(), and remapExtension().

std::map<std::string, std::string> NLMISC::CPath::_RemappedFiles [private]

Definition at line 233 of file path.h. Referenced by remapFile().

std::vector<std::string> NLMISC::CPath::IgnoredFiles [private]

Definition at line 231 of file path.h.

CStaticStringMapper NLMISC::CPath::SSMext [private]

Definition at line 240 of file path.h. Referenced by getFileList(), and remapExtension().

CStaticStringMapper NLMISC::CPath::SSMpath [private]

Definition at line 241 of file path.h. Referenced by memoryCompress(), and remapExtension().

---

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

• path.h
• path.cpp

---