osg::PathHandler Class Reference
[Base]

#include <OSGPathHandler.h>

List of all members.

Public Member Functions
Constructors
*	PathHandler (void)
	PathHandler (const Char8 *initialPathList)
Destructor
*virtual	~PathHandler (void)
Get
*std::string	findFile (const Char8 *fileName)
const std::string &	getBaseFile (void) const
Set
*void	push_backPath (const Char8 *pathList)
void	push_backCurrentDir (void)
void	push_backUnixPath (const Char8 *pathList)
void	push_backWin32Path (const Char8 *pathList)
void	push_frontPath (const Char8 *pathList)
void	push_frontCurrentDir (void)
void	push_frontUnixPath (const Char8 *pathList)
void	push_frontWin32Path (const Char8 *pathList)
void	subPath (const Char8 *pathList)
void	subUnixPath (const Char8 *pathList)
void	subWin32Path (const Char8 *pathList)
void	clearPathList (void)
void	setBaseFile (const Char8 *fileName)
void	clearBaseFile (void)
std::string	extractPath (const Char8 *szFilename)
Dump
*void	dump (void)
Protected Types
typedef std::list< std::string >	PathList
typedef std::list< std::string >::iterator	PathListIter
enum	PathType {   Win32Path = 0x0001, UnixPath = 0x0002, AbsPath = 0x0100, PlatformMask = 0x00FF,   TypeMask = 0xFF00 }
Protected Member Functions
Helper
*void	validateList (PathList &pathList)
PathType	analysePathList (const Char8 *pathList)
PathType	analysePath (const Char8 *path)
void	expandWin32Path (std::string &path)
void	expandUnixPath (std::string &path)
void	push_backPathList (PathList &pathList)
void	push_frontPathList (PathList &pathList)
void	subPathList (const PathList &pathList)
void	convertPath (std::string &path)
void	convertWin32PathList (PathList &result)
void	convertUnixPathList (PathList &result)
void	splitPathList (const Char8 *pathList, const Char8 pathSep, PathList &result)
void	parsePathList (const Char8 *pathList, PathList &result)
void	parseUnixPathList (const Char8 *pathList, PathList &result)
void	parseWin32PathList (const Char8 *pathList, PathList &result)
Protected Attributes
Member
*PathList	_pathList
std::string	_baseFilePath
Static Protected Attributes
Static Constants
*static const Char8	_dirSepWin32 = '\\'
static const Char8	_pathSepWin32 = ';'
static const Char8	_dirSepUnix = '/'
static const Char8	_pathSepUnix = ':'
static const Char8	_dirSep = _dirSepUnix
static const Char8	_pathSep = _pathSepUnix
static const Char8	_dirSepOther = _dirSepWin32
static const Char8	_pathSepOther = _pathSepWin32
Private Member Functions
	PathHandler (const PathHandler &source)
	prohibit default function (move to 'public' if needed)
void	operator= (const PathHandler &source)
	prohibit default function (move to 'public' if needed)

---

Detailed Description

Definition at line 63 of file OSGPathHandler.h.

---

Member Typedef Documentation

typedef std::list<std::string> osg::PathHandler::PathList [protected]

Definition at line 143 of file OSGPathHandler.h.

typedef std::list<std::string>::iterator osg::PathHandler::PathListIter [protected]

Definition at line 144 of file OSGPathHandler.h.

---

Member Enumeration Documentation

enum osg::PathHandler::PathType [protected]

Enumerator: Win32Path  UnixPath  AbsPath  PlatformMask  TypeMask  Definition at line 132 of file OSGPathHandler.h. { Win32Path = 0x0001, UnixPath = 0x0002, AbsPath = 0x0100, PlatformMask = 0x00FF, TypeMask = 0xFF00 };

---

Constructor & Destructor Documentation

PathHandler::PathHandler (  void   )

Definition at line 74 of file OSGPathHandler.cpp. : _pathList (), _baseFilePath() { }

PathHandler::PathHandler (  const Char8 *  initialPathList  )

Definition at line 80 of file OSGPathHandler.cpp. References push_backUnixPath(). { push_backUnixPath(initialPathList); }

PathHandler::~PathHandler (  void   )  [virtual]

Definition at line 87 of file OSGPathHandler.cpp. { }

osg::PathHandler::PathHandler (  const PathHandler &  source  )  [private]

---

Member Function Documentation

std::string PathHandler::findFile (  const Char8 *  fileName  )

Definition at line 93 of file OSGPathHandler.cpp. References _baseFilePath, _pathList, AbsPath, analysePath(), osg::AccessFlags::IsReadable, parsePathList(), SINFO, osg::File::tstAttr(), and TypeMask. Referenced by osg::ProxyGroup::changed(), osg::VRMLInlineDesc::endNode(), osg::SceneFileHandler::initPathHandler(), osg::ImageFileHandler::read(), osg::DATImageFileType::read(), and osg::OBJSceneFileType::readMTL(). { std::string returnValue; bool bFound = false; PathList tmpList; PathListIter iter = _pathList.begin(); PathListIter listEnd = _pathList.end(); PathType pType = analysePath(fileName); parsePathList(fileName, tmpList); if(tmpList.size() != 0) { if((pType & TypeMask) == AbsPath) { SINFO << "Check abs : " << tmpList.front() << std::endl; if(File::tstAttr(tmpList.front().c_str(), AccessFlags::IsReadable)) { returnValue.assign(fileName); } } else { if(_baseFilePath.empty() == false) { returnValue.assign(_baseFilePath); returnValue.append(tmpList.front()); SINFO << "Check base : " << returnValue << std::endl; if(File::tstAttr(returnValue.c_str(), AccessFlags::IsReadable) == false) { returnValue.erase(); } else { bFound = true; } } if(bFound == false) { while(iter != listEnd) { returnValue.assign(*iter); returnValue.append(tmpList.front()); SINFO << "Check from pl : " << returnValue << std::endl; if(File::tstAttr(returnValue.c_str(), AccessFlags::IsReadable) == true) { break; } ++iter; } if(iter == listEnd) { returnValue.erase(); } } } } return returnValue; }

const std::string & PathHandler::getBaseFile (  void   )  const

Definition at line 169 of file OSGPathHandler.cpp. References _baseFilePath. Referenced by osg::Image::read(). { return _baseFilePath; }

void PathHandler::push_backPath (  const Char8 *  pathList  )

Definition at line 176 of file OSGPathHandler.cpp. References parsePathList(), and push_backPathList(). Referenced by osg::VRMLInlineDesc::endNode(). { PathList tmpList; parsePathList(pathList, tmpList); push_backPathList(tmpList); }

void PathHandler::push_backCurrentDir (  void   )

Definition at line 185 of file OSGPathHandler.cpp. References _pathList, osg::Directory::getCurrent(), and validateList(). { Char8 *pCurrentDir = Directory::getCurrent(); std::string tmpString = pCurrentDir; _pathList.push_back(tmpString); validateList(_pathList); delete [] pCurrentDir; }

void PathHandler::push_backUnixPath (  const Char8 *  pathList  )

Definition at line 197 of file OSGPathHandler.cpp. References parseUnixPathList(), and push_backPathList(). Referenced by PathHandler(). { PathList tmpList; parseUnixPathList(pathList, tmpList); push_backPathList(tmpList); }

void PathHandler::push_backWin32Path (  const Char8 *  pathList  )

Definition at line 206 of file OSGPathHandler.cpp. References parseWin32PathList(), and push_backPathList(). { PathList tmpList; parseWin32PathList(pathList, tmpList); push_backPathList(tmpList); }

void PathHandler::push_frontPath (  const Char8 *  pathList  )

Definition at line 216 of file OSGPathHandler.cpp. References parsePathList(), and push_frontPathList(). { PathList tmpList; parsePathList(pathList, tmpList); push_frontPathList(tmpList); }

void PathHandler::push_frontCurrentDir (  void   )

Definition at line 225 of file OSGPathHandler.cpp. References _pathList, osg::Directory::getCurrent(), and validateList(). Referenced by osg::SceneFileHandler::initPathHandler(). { Char8 *pCurrentDir = Directory::getCurrent(); std::string tmpString = pCurrentDir; _pathList.push_front(tmpString); validateList(_pathList); delete [] pCurrentDir; }

void PathHandler::push_frontUnixPath (  const Char8 *  pathList  )

Definition at line 237 of file OSGPathHandler.cpp. References parseUnixPathList(), and push_frontPathList(). { PathList tmpList; parseUnixPathList(pathList, tmpList); push_frontPathList(tmpList); }

void PathHandler::push_frontWin32Path (  const Char8 *  pathList  )

Definition at line 246 of file OSGPathHandler.cpp. References parseWin32PathList(), and push_frontPathList(). { PathList tmpList; parseWin32PathList(pathList, tmpList); push_frontPathList(tmpList); }

void PathHandler::subPath (  const Char8 *  pathList  )

Definition at line 255 of file OSGPathHandler.cpp. References parsePathList(), subPathList(), and validateList(). Referenced by osg::VRMLInlineDesc::endNode(). { PathList tmpList; parsePathList(pathList, tmpList); validateList(tmpList); subPathList(tmpList); }

void PathHandler::subUnixPath (  const Char8 *  pathList  )

Definition at line 264 of file OSGPathHandler.cpp. References parseUnixPathList(), subPathList(), and validateList(). { PathList tmpList; parseUnixPathList(pathList, tmpList); validateList(tmpList); subPathList(tmpList); }

void PathHandler::subWin32Path (  const Char8 *  pathList  )

Definition at line 273 of file OSGPathHandler.cpp. References parseWin32PathList(), subPathList(), and validateList(). { PathList tmpList; parseWin32PathList(pathList, tmpList); validateList(tmpList); subPathList(tmpList); }

void PathHandler::clearPathList (  void   )

Definition at line 282 of file OSGPathHandler.cpp. References _pathList. Referenced by osg::SceneFileHandler::initPathHandler(). { _pathList.clear(); }

void PathHandler::setBaseFile (  const Char8 *  fileName  )

Definition at line 288 of file OSGPathHandler.cpp. References _baseFilePath, and extractPath(). Referenced by osg::SceneFileHandler::initPathHandler(). { if(fileName != NULL) { _baseFilePath = extractPath(fileName); } }

void PathHandler::clearBaseFile (  void   )

Definition at line 296 of file OSGPathHandler.cpp. References _baseFilePath. { _baseFilePath.erase(); }

std::string PathHandler::extractPath (  const Char8 *  szFilename  )

Definition at line 348 of file OSGPathHandler.cpp. References _dirSep, analysePathList(), convertPath(), PlatformMask, and Win32Path. Referenced by setBaseFile(). { std::string returnValue(szFilename); std::string::size_type pos = returnValue.find_last_of("\\/"); if(pos != std::string::npos) { if(pos != returnValue.length() - 1) { returnValue.erase(pos + 1); } } else { returnValue.assign("."); } PathType pType = analysePathList(returnValue.c_str()); if((pType & PlatformMask) == Win32Path) { #ifndef WIN32 convertPath(returnValue); #endif } else { #ifdef WIN32 convertPath(returnValue); #endif } if(returnValue[returnValue.length() - 1] != _dirSep) { returnValue += _dirSep; } return returnValue; }

void PathHandler::dump (  void   )

Definition at line 303 of file OSGPathHandler.cpp. References _baseFilePath, _pathList, and SLOG. { PathListIter iter = _pathList.begin(); if(_baseFilePath.size() != 0) { SLOG << "Base file path : " << _baseFilePath << std::endl; } else { SLOG << "Base file path : empty" << std::endl; } for( ; iter != _pathList.end(); ++iter ) { SLOG << "\"" << *iter << "\"" << std::endl; } }

void PathHandler::validateList (  PathList &  pathList  )  [protected]

Definition at line 324 of file OSGPathHandler.cpp. References _dirSep. Referenced by push_backCurrentDir(), push_backPathList(), push_frontCurrentDir(), push_frontPathList(), subPath(), subUnixPath(), and subWin32Path(). { PathListIter iter = pathList.begin(); PathListIter listEnd = pathList.end(); while(iter != listEnd) { if(iter->empty() == true) { (*iter) += '.'; (*iter) += _dirSep; } else { if((*iter)[iter->length() - 1] != _dirSep) { (*iter) += _dirSep; } } ++iter; } }

PathHandler::PathType PathHandler::analysePathList (  const Char8 *  pathList  )  [protected]

Definition at line 389 of file OSGPathHandler.cpp. References UnixPath, and Win32Path. Referenced by extractPath(), and parsePathList(). { PathType returnValue = UnixPath; const Char8 *pCurr = pathList; if(pathList == NULL) return returnValue; while(*pCurr != '\0') { if(*pCurr == '\\') { returnValue = Win32Path; break; } else if(*pCurr == ';') { returnValue = Win32Path; break; } else if(*pCurr == '%') { returnValue = Win32Path; break; } else if(*pCurr == '/') { returnValue = UnixPath; break; } else if(*pCurr == '$') { returnValue = UnixPath; break; } else if(*pCurr == ':') { if(*(pCurr + 1) == '\\') { returnValue = Win32Path; break; } } pCurr++; } #ifdef WIN32 // HACK but d:/data/tie.wrl is also a valid windows path. if(returnValue == UnixPath) { // ok first look for a ";" in the path list. UInt32 uiSize = 0; pCurr = pathList; while(*pCurr != '\0') { if(*pCurr == ';') { returnValue = Win32Path; break; } pCurr++; uiSize++; } // ok we found no ";" in the list look for a absolute windows path. if(returnValue == UnixPath) { if(uiSize >= 3) { if(pathList[1] == ':' && (pathList[2] == '/' || pathList[2] == '\\')) { returnValue = Win32Path; } } } } #endif return returnValue; }

PathHandler::PathType PathHandler::analysePath (  const Char8 *  path  )  [protected]

Definition at line 472 of file OSGPathHandler.cpp. References AbsPath, UnixPath, and Win32Path. Referenced by findFile(). { PathType returnValue = UnixPath; UInt32 uiSize = 0; const Char8 *pCurr = path; if(path == NULL) return returnValue; while(*pCurr != '\0') { if(*pCurr == '\\') { returnValue = Win32Path; break; } else if(*pCurr == ';') { returnValue = Win32Path; break; } else if(*pCurr == '%') { returnValue = Win32Path; break; } else if(*pCurr == '/') { returnValue = UnixPath; break; } else if(*pCurr == '$') { returnValue = UnixPath; break; } else if(*pCurr == ':') { if(*(pCurr + 1) == '\\') { returnValue = Win32Path; uiSize++; break; } } pCurr++; uiSize++; } #ifdef WIN32 if(returnValue == UnixPath) { // d:/data/tie.wrl is also a windows path! if(uiSize >= 2) { if(path[1] == ':') returnValue = Win32Path; } } #endif if(returnValue == Win32Path) { if(uiSize >= 2) { if(path[1] == ':') returnValue = (PathType) (returnValue | AbsPath); } else { // windows network path. if(path[0] == '\\' && path[1] == '\\') returnValue = (PathType) (returnValue | AbsPath); } } else { if(path[0] == '/') returnValue = (PathType) (returnValue | AbsPath); } return returnValue; }

void PathHandler::expandWin32Path (  std::string &  path  )  [protected]

Definition at line 557 of file OSGPathHandler.cpp. References FWARNING. Referenced by convertWin32PathList(). { std::string envVar; std::string::size_type currPos = 0; std::string::size_type startPos = 0; while(currPos < path.size()) { if(path[currPos] == '%') { envVar.erase(); startPos = currPos++; while(path[currPos] != '%' && currPos < path.size()) { envVar += path[currPos++]; } if(currPos < path.size()) { currPos++; } Char8 *szEnvVal = getenv(envVar.c_str()); if(szEnvVal == NULL) { FWARNING(("Could not find env var %s\n", envVar.c_str())); } else { path.replace(startPos, currPos - startPos, szEnvVal); } } else { currPos++; } } }

void PathHandler::expandUnixPath (  std::string &  path  )  [protected]

Definition at line 600 of file OSGPathHandler.cpp. References FWARNING. Referenced by convertUnixPathList(). { std::string envVar; std::string userName; std::string userHome; #ifndef WIN32 bool stop; passwd *userInfo; #endif std::string::size_type currPos = 0; std::string::size_type startPos = 0; while(currPos < path.size()) { if(path[currPos] == '$') { envVar.erase(); startPos = currPos++; while(path[currPos] != ':' && path[currPos] != '/' && path[currPos] != '$' && currPos < path.size()) { envVar += path[currPos++]; } Char8 *szEnvVal = getenv(envVar.c_str()); if(szEnvVal == NULL) { FWARNING(("Could not find env var %s\n", envVar.c_str())); } else { path.replace(startPos, currPos - startPos, szEnvVal); } } #ifndef WIN32 else if(path[currPos] == '~') { userName.erase(); startPos = currPos++; while(path[currPos] != ':' && path[currPos] != '/' && path[currPos] != '$' && currPos < path.size()) { userName += path[currPos++]; } if(!userName.empty()) { setpwent(); //prepare access to user db stop = false; while(stop == false) { if((userInfo=getpwent()) != NULL ) { if(strcmp(userName.c_str(), userInfo->pw_name) == 0) { stop = true; userHome = userInfo->pw_dir; } } else { stop = true; } } endpwent(); } else { if((userInfo=getpwuid(getuid())) != NULL) { userHome = userInfo->pw_dir; } } if(userHome.empty() == false) { path.replace(startPos, currPos - startPos, userHome); } else { FWARNING(("Could not find user home %s\n", userHome.c_str())); } } #endif else { currPos++; } } }

void PathHandler::push_backPathList (  PathList &  pathList  )  [protected]

Definition at line 700 of file OSGPathHandler.cpp. References _pathList, and validateList(). Referenced by push_backPath(), push_backUnixPath(), and push_backWin32Path(). { _pathList.splice(_pathList.end(), pathList); validateList(_pathList); }

void PathHandler::push_frontPathList (  PathList &  pathList  )  [protected]

Definition at line 707 of file OSGPathHandler.cpp. References _pathList, and validateList(). Referenced by push_frontPath(), push_frontUnixPath(), and push_frontWin32Path(). { _pathList.splice(_pathList.begin(), pathList); validateList(_pathList); }

void PathHandler::subPathList (  const PathList &  pathList  )  [protected]

Definition at line 714 of file OSGPathHandler.cpp. References _pathList. Referenced by subPath(), subUnixPath(), and subWin32Path(). { for(PathList::const_iterator i = pathList.begin();i != pathList.end();++i) { for(PathList::iterator j = _pathList.begin();j != _pathList.end();++j) { if(*j == *i) { _pathList.erase(j); break; } } } }

void PathHandler::convertPath (  std::string &  path  )  [protected]

Definition at line 729 of file OSGPathHandler.cpp. References _dirSep, and _dirSepOther. Referenced by convertUnixPathList(), convertWin32PathList(), and extractPath(). { std::string::iterator stringIt = path.begin(); std::string::iterator stringEnd = path.end (); while(stringIt != stringEnd) { if(*stringIt == _dirSepOther) { *stringIt = _dirSep; } stringIt++; }; }

void PathHandler::convertWin32PathList (  PathList &  result  )  [protected]

Definition at line 745 of file OSGPathHandler.cpp. References convertPath(), and expandWin32Path(). Referenced by parseWin32PathList(). { PathListIter iter = result.begin(); PathListIter endList = result.end(); while(iter != endList) { expandWin32Path(*iter); #ifndef WIN32 convertPath (*iter); #endif iter++; }; }

void PathHandler::convertUnixPathList (  PathList &  result  )  [protected]

Definition at line 762 of file OSGPathHandler.cpp. References convertPath(), and expandUnixPath(). Referenced by parseUnixPathList(). { PathListIter iter = result.begin(); PathListIter endList = result.end(); while(iter != endList) { expandUnixPath(*iter); #ifdef WIN32 convertPath (*iter); #endif iter++; }; }

void PathHandler::splitPathList (  const Char8 *  pathList, const Char8  pathSep, PathList &  result )  [protected]

Definition at line 779 of file OSGPathHandler.cpp. Referenced by parseUnixPathList(), and parseWin32PathList(). { std::string::size_type currPos = 0; std::string::size_type startPos = 0; std::string workString(pathList); currPos = workString.find(pathSep); if(currPos == std::string::npos) { result.push_back(workString); } else { while(currPos != std::string::npos) { result.push_back(workString.substr(startPos, currPos - startPos)); startPos = currPos + 1; currPos = workString.find(pathSep, startPos); } if(startPos != 0) { result.push_back(workString.substr(startPos)); } } }

void PathHandler::parsePathList (  const Char8 *  pathList, PathList &  result )  [protected]

Definition at line 812 of file OSGPathHandler.cpp. References analysePathList(), parseUnixPathList(), parseWin32PathList(), PlatformMask, and Win32Path. Referenced by findFile(), push_backPath(), push_frontPath(), and subPath(). 00813 { 00814 PathType pType = analysePathList(pathList); 00815 00816 if((pType & PlatformMask) == Win32Path) 00817 { 00818 parseWin32PathList(pathList, result); 00819 } 00820 else 0