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
enum	PathType {   Win32Path = 0x0001, UnixPath = 0x0002, AbsPath = 0x0100, PlatformMask = 0x00FF,   TypeMask = 0xFF00 }
typedef std::list< std::string >	PathList
typedef std::list< std::string > ::iterator	PathListIter
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::HDRImageFileType::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);

    // doesn't work for filenames with ;
    parsePathList(fileName, tmpList);

    if(tmpList.size() != 0)
    {
        if((pType & TypeMask) == AbsPath)
        {
            SINFO << "Check abs : " << fileName << std::endl;

            if(File::tstAttr(fileName,
                             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 170 of file OSGPathHandler.cpp.

References _baseFilePath.

Referenced by osg::ImageFileHandler::read().

{
  return _baseFilePath;
}

void PathHandler::push_backPath

(

const Char8 *

pathList

)

Definition at line 177 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 186 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 198 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 207 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 217 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 226 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 238 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 247 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 256 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 265 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 274 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 283 of file OSGPathHandler.cpp.

References _pathList.

Referenced by osg::SceneFileHandler::initPathHandler().

{
    _pathList.clear();
}

void PathHandler::setBaseFile

(

const Char8 *

fileName

)

Definition at line 289 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 297 of file OSGPathHandler.cpp.

References _baseFilePath.

Referenced by osg::SceneFileHandler::initPathHandler().

{
    _baseFilePath.erase();
}

std::string PathHandler::extractPath

(

const Char8 *

szFilename

)

Definition at line 349 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 304 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 325 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 390 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 473 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 558 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 601 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 701 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 708 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 715 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 730 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 746 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 763 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 780 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 813 of file OSGPathHandler.cpp.

References analysePathList(), parseUnixPathList(), parseWin32PathList(), PlatformMask, and Win32Path.

Referenced by findFile(), push_backPath(), push_frontPath(), and subPath().

{
    PathType pType = analysePathList(pathList);

    if((pType & PlatformMask) == Win32Path)
    {
        parseWin32PathList(pathList, result);
    }
    else
    {
        parseUnixPathList (pathList, result);
    }
}

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

Definition at line 827 of file OSGPathHandler.cpp.

References _pathSepUnix, convertUnixPathList(), and splitPathList().

Referenced by parsePathList(), push_backUnixPath(), push_frontUnixPath(), and subUnixPath().

{
    if(pathList == NULL)
        return;

    splitPathList      (pathList, _pathSepUnix, result);

    convertUnixPathList(result);
}

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

Definition at line 837 of file OSGPathHandler.cpp.

References _pathSepWin32, convertWin32PathList(), and splitPathList().

Referenced by parsePathList(), push_backWin32Path(), push_frontWin32Path(), and subWin32Path().

{
    if(pathList == NULL)
        return;

    splitPathList     (pathList, _pathSepWin32, result);

    convertWin32PathList(result);
}

void osg::PathHandler::operator=

(

const PathHandler &

source

)

[private]

---

Member Data Documentation

const Char8 PathHandler::_dirSepWin32 = '\\' [static, protected]

Definition at line 150 of file OSGPathHandler.h.

const Char8 PathHandler::_pathSepWin32 = ';' [static, protected]

Definition at line 151 of file OSGPathHandler.h.

Referenced by parseWin32PathList().

const Char8 PathHandler::_dirSepUnix = '/' [static, protected]

Definition at line 153 of file OSGPathHandler.h.

const Char8 PathHandler::_pathSepUnix = ':' [static, protected]

Definition at line 154 of file OSGPathHandler.h.

Referenced by parseUnixPathList().

const Char8 PathHandler::_dirSep = _dirSepUnix [static, protected]

Definition at line 156 of file OSGPathHandler.h.

Referenced by convertPath(), extractPath(), and validateList().

const Char8 PathHandler::_pathSep = _pathSepUnix [static, protected]

Definition at line 157 of file OSGPathHandler.h.

const Char8 PathHandler::_dirSepOther = _dirSepWin32 [static, protected]

Definition at line 159 of file OSGPathHandler.h.

Referenced by convertPath().

const Char8 PathHandler::_pathSepOther = _pathSepWin32 [static, protected]

Definition at line 160 of file OSGPathHandler.h.

PathList osg::PathHandler::_pathList [protected]

Definition at line 167 of file OSGPathHandler.h.

Referenced by clearPathList(), dump(), findFile(), push_backCurrentDir(), push_backPathList(), push_frontCurrentDir(), push_frontPathList(), and subPathList().

std::string osg::PathHandler::_baseFilePath [protected]

Definition at line 168 of file OSGPathHandler.h.

Referenced by clearBaseFile(), dump(), findFile(), getBaseFile(), and setBaseFile().

---

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

• OSGPathHandler.h
• OSGPathHandler.cpp