#include <CDirEntry.h>

Collaboration diagram for CDirEntry:

Static Public Member Functions
static std::string	baseName (const std::string &path)

static std::vector< std::string >	compilePattern (const std::string &pattern)

static bool	createDir (const std::string &dir, const std::string &parent="")

static std::string	createTmpName (const std::string &dir, const std::string &suffix)

static std::string	dirName (const std::string &path)

static bool	exist (const std::string &path)

static std::string	fileName (const std::string &path)

static bool	isDir (const std::string &path)

static bool	isFile (const std::string &path)

static bool	isReadable (const std::string &path)

static bool	isRelativePath (const std::string &path)

static bool	isWritable (const std::string &path)

static bool	makePathAbsolute (std::string &relativePath, const std::string &absoluteTo)

static bool	makePathRelative (std::string &absolutePath, const std::string &relativeTo)

static bool	match (const std::string &name, const std::vector< std::string > &patternList)

static bool	move (const std::string &from, const std::string &to)

static std::string	normalize (const std::string &path)

static bool	remove (const std::string &path)

static bool	removeFiles (const std::string &pattern, const std::string &dir)

static std::string	suffix (const std::string &path)

Static Public Attributes
static const std::string	Separator = "/"

Static Private Member Functions
static bool	matchInternal (const std::string &name, const std::string pattern, std::string::size_type &at, std::string::size_type &after)

Detailed Description

This class provides an OS independent interface to directory entries such as files and directories.

Definition at line 28 of file CDirEntry.h.

Member Function Documentation

std::string CDirEntry::baseName ( const std::string & path )

static

Returns the base name, i.e., the directory path and the the suffix are removed from 'path'.

Parameters

const std::string & path

Returns: std::string baseName

Definition at line 98 of file CDirEntry.cpp.

References Separator.

Referenced by CCopasiDataModel::autoSave(), CCopasiDataModel::importSBML(), CCopasiDataModel::loadModel(), main(), CopasiUI3Window::slotExportMathModel(), CopasiUI3Window::slotExportSBML(), and CopasiUI3Window::updateTitle().

 {
   std::string::size_type start = path.find_last_of(Separator);
 #ifdef WIN32 // WIN32 also understands '/' as the separator.
 
   if (start == std::string::npos)
     start = path.find_last_of("/");
 
 #endif
 
   if (start == std::string::npos) start = 0;
   else start++; // We do not want the separator.
 
   std::string::size_type end = path.find_last_of(".");
 
   if (end == std::string::npos || end < start)
     end = path.length();
 
   return path.substr(start, end - start);
 }

std::vector< std::string > CDirEntry::compilePattern ( const std::string & pattern )

static

Compiles the pattern to a patternList. Valid wildcards in the pattern are: '*' matches any number of characters and '?' matches exactly one character.

Parameters

const std::string & pattern

Returns: std::vector< std::string > patternList

Definition at line 372 of file CDirEntry.cpp.

References min.

Referenced by removeFiles().

 {
   std::string::size_type pos = 0;
   std::string::size_type start = 0;
   std::string::size_type end = 0;
   std::vector< std::string > PatternList;
 
   while (pos != std::string::npos)
     {
       start = pos;
       pos = pattern.find_first_of("*?", pos);
 
       end = std::min(pos, pattern.length());
 
       if (start != end)
         PatternList.push_back(pattern.substr(start, end - start));
       else
         {
           PatternList.push_back(pattern.substr(start, 1));
           pos++;
         }
     };
 
   return PatternList;
 }

bool CDirEntry::createDir	(	const std::string &	dir,
		const std::string &	parent = `""`
	)

static

Create the directory 'dir' in the parent directory 'parent'.

Parameters

const	std::string & dir
const	std::string & parent (Default: current working directory)

Returns: bool success

Definition at line 180 of file CDirEntry.cpp.

References CLocaleString::fromUtf8(), isDir(), isWritable(), and Separator.

Referenced by COptions::getConfigDir(), and COptions::getTemp().

 {
   std::string Dir;
 
   if (parent != "") Dir = parent + Separator;
 
   Dir += dir;
 
   // Check whether the directory already exists and is writable.
   if (isDir(Dir) && isWritable(Dir)) return true;
 
   // Check whether the parent directory exists and is writable.
   if (!isDir(parent) || !isWritable(parent)) return false;
 
 #ifdef WIN32
   return (mkdir(CLocaleString::fromUtf8(Dir).c_str()) == 0);
 #else
   return (mkdir(CLocaleString::fromUtf8(Dir).c_str(), S_IRWXU | S_IRWXG | S_IRWXO) == 0);
 #endif
 }

std::string CDirEntry::createTmpName	(	const std::string &	dir,
		const std::string &	suffix
	)

static

Create a name for a temporary directory entry. The directory entry will be located in the directory given

Parameters

const	std::string & dir
const	std::string & suffix

Returns: std::string tmpName

Definition at line 202 of file CDirEntry.cpp.

References C_INT32, CRandom::createGenerator(), exist(), CRandom::getRandomU(), pdelete, Separator, and suffix().

Referenced by CCopasiDataModel::saveModel().

 {
   CRandom * pRandom = CRandom::createGenerator();
 
   std::string RandomName;
 
   do
     {
       RandomName = dir + Separator;
       unsigned C_INT32 Char;
 
       for (size_t i = 0; i < 8; i++)
         {
           Char = pRandom->getRandomU(35);
 
           if (Char < 10)
             RandomName += '0' + Char;
           else
             RandomName += 'a' - 10 + Char;
         }
 
       RandomName += suffix;
     }
   while (exist(RandomName));
 
   pdelete(pRandom);
 
   return RandomName;
 }

std::string CDirEntry::dirName ( const std::string & path )

static

Returns the directory path to the parent directoryu, i.e., the file name or directory name are removed from 'path'.

Parameters

const std::string & path

Returns: std::string dirName

Definition at line 135 of file CDirEntry.cpp.

References Separator.

Referenced by CCopasiDataModel::exportMathModel(), CSEDMLExporter::exportModelAndTasks(), COptions::getCopasiDir(), CopasiFileDialog::getOpenFileName(), CopasiFileDialog::getSaveFileName(), SEDMLImporter::importFirstSBMLModel(), CCopasiDataModel::importSBML(), COptions::init(), CCopasiDataModel::loadModel(), makePathAbsolute(), makePathRelative(), CopasiUI3Window::slotExportMathModel(), CopasiUI3Window::slotExportSBML(), and CopasiFileDialog::StartWith().

 {
   if (path == "") return path;
 
 #ifdef WIN32 // WIN32 also understands '/' as the separator.
   std::string::size_type end = path.find_last_of(Separator + "/");
 #else
   std::string::size_type end = path.find_last_of(Separator);
 #endif
 
   if (end == path.length() - 1)
     {
 #ifdef WIN32 // WIN32 also understands '/' as the separator.
       end = path.find_last_of(Separator + "/", end);
 #else
       end = path.find_last_of(Separator, end);
 #endif
     }
 
   if (end == std::string::npos) return "";
 
   return path.substr(0, end);
 }

bool CDirEntry::exist ( const std::string & path )

static

Check whether the directory entry specified by 'path' exists.

Parameters

const std::string & path

Returns: bool exist

Definition at line 78 of file CDirEntry.cpp.

References CLocaleString::fromUtf8().

Referenced by createTmpName(), createUniqueModelFileName(), CCopasiDataModel::exportMathModel(), CCopasiDataModel::exportSBML(), SEDMLImporter::importFirstSBMLModel(), move(), and CCopasiDataModel::saveModel().

 {
   STAT st;
 
   if (stat(CLocaleString::fromUtf8(path).c_str(), & st) == -1) return false;
 
 #ifdef WIN32
   return ((st.st_mode & S_IFREG) == S_IFREG ||
           (st.st_mode & S_IFDIR) == S_IFDIR);
 #else
   return (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode));
 #endif
 }

std::string CDirEntry::fileName ( const std::string & path )

static

Returns the file name, i.e., the directory path is removed from 'path'.

Parameters

const std::string & path

Returns: std::string fileName

Definition at line 119 of file CDirEntry.cpp.

References Separator.

Referenced by CRecentFiles::addFile(), CCopasiDataModel::exportSBML(), CExperiment::getFileName(), CopasiFileDialog::getSaveFileName(), CCopasiDataModel::importSBML(), CQExperimentData::load(), CCopasiDataModel::loadModel(), move(), CReport::open(), CCopasiDataModel::saveModel(), CCopasiXMLInterface::saveParameter(), CCopasiXML::saveSBMLReference(), CCopasiXML::saveTaskList(), CCopasiDataModel::setSBMLFileName(), CQExperimentData::slotFileAdd(), and Copasi2SBMLTranslator::translate().

 {
   std::string::size_type start = path.find_last_of(Separator);
 #ifdef WIN32 // WIN32 also understands '/' as the separator.
 
   if (start == std::string::npos)
     start = path.find_last_of("/");
 
 #endif
 
   if (start == std::string::npos) start = 0;
   else start++; // We do not want the separator.
 
   return path.substr(start);
 }

bool CDirEntry::isDir ( const std::string & path )

static

Check whether the directory entry specified by 'path' is is a directory.

Parameters

const std::string & path

Returns: bool isDir

Definition at line 65 of file CDirEntry.cpp.

References CLocaleString::fromUtf8().

Referenced by createDir(), COptions::getTemp(), makePathAbsolute(), makePathRelative(), move(), CopasiFileDialog::openExampleDir(), remove(), and removeFiles().

 {
   STAT st;
 
   if (stat(CLocaleString::fromUtf8(path).c_str(), & st) == -1) return false;
 
 #ifdef WIN32
   return ((st.st_mode & S_IFDIR) == S_IFDIR);
 #else
   return S_ISDIR(st.st_mode);
 #endif
 }

bool CDirEntry::isFile ( const std::string & path )

static

Check whether the directory entry specified by 'path' is a file.

Parameters

const std::string & path

Returns: bool isFile

Definition at line 52 of file CDirEntry.cpp.

References CLocaleString::fromUtf8().

Referenced by makePathAbsolute(), makePathRelative(), move(), and remove().

 {
   STAT st;
 
   if (stat(CLocaleString::fromUtf8(path).c_str(), & st) == -1) return false;
 
 #ifdef WIN32
   return ((st.st_mode & S_IFREG) == S_IFREG);
 #else
   return S_ISREG(st.st_mode);
 #endif
 }

bool CDirEntry::isReadable ( const std::string & path )

static

Check whether the directory entry specified by 'path' is is readable.

Parameters

const std::string & path

Returns: bool isReadable

Definition at line 92 of file CDirEntry.cpp.

References CLocaleString::fromUtf8().

93 {return (access(CLocaleString::fromUtf8(path).c_str(), 0x4) == 0);}

CLocaleString::fromUtf8

static CLocaleString fromUtf8(const std::string &utf8)

Definition: CLocaleString.cpp:50

bool CDirEntry::isRelativePath ( const std::string & path )

static

Checks whether the given path is relative

Returns: bool isRelative

Definition at line 414 of file CDirEntry.cpp.

References normalize().

Referenced by CRecentFiles::addFile(), CCopasiDataModel::exportSBML(), CExperiment::getFileName(), CCopasiDataModel::importSBML(), COptions::init(), CCopasiDataModel::loadModel(), makePathAbsolute(), makePathRelative(), CReport::open(), CCopasiDataModel::saveModel(), CCopasiXMLInterface::saveParameter(), CCopasiXML::saveSBMLReference(), CCopasiXML::saveTaskList(), and CCopasiDataModel::setSBMLFileName().

 {
 #ifdef WIN32
   std::string Path = normalize(path);
 
   if (Path.length() < 2)
     return true;
 
   if (Path[1] == ':')
     return false;
 
   if (Path[0] == '/' && Path[1] == '/')
     return false;
 
   return true;
 #else
   return (path.length() < 1 || path[0] != '/');
 #endif
 }

bool CDirEntry::isWritable ( const std::string & path )

static

Check whether the directory entry specified by 'path' is writable.

Parameters

const std::string & path

Returns: bool isWritable

Definition at line 95 of file CDirEntry.cpp.

References CLocaleString::fromUtf8().

Referenced by checkSelection(), createDir(), CCopasiDataModel::exportMathModel(), CCopasiDataModel::exportSBML(), COptions::getTemp(), CCopasiDataModel::saveModel(), and CopasiUI3Window::slotFileOpenFinished().

96 {return (access(CLocaleString::fromUtf8(path).c_str(), 0x2) == 0);}

CLocaleString::fromUtf8

static CLocaleString fromUtf8(const std::string &utf8)

Definition: CLocaleString.cpp:50

bool CDirEntry::makePathAbsolute	(	std::string &	relativePath,
		const std::string &	absoluteTo
	)

static

Makes the relative path absolute to the path given in absoluteTo

Parameters

std::string	& relativePath
const	std::string & absoluteTo

Returns: bool success

Definition at line 481 of file CDirEntry.cpp.

References dirName(), isDir(), isFile(), isRelativePath(), and normalize().

Referenced by CRecentFiles::addFile(), CCopasiDataModel::exportSBML(), CExperiment::getFileName(), CCopasiDataModel::importSBML(), COptions::init(), CCopasiDataModel::loadModel(), CReport::open(), CCopasiDataModel::saveModel(), CCopasiDataModel::setSBMLFileName(), CLImageTexturizer::to_absolute_path(), and Copasi2SBMLTranslator::translate().

 {
   if (!isRelativePath(relativePath) ||
       isRelativePath(absoluteTo)) return false; // Nothing can be done.
 
   std:: string AbsoluteTo = normalize(absoluteTo);
 
   if (isFile(AbsoluteTo)) AbsoluteTo = dirName(AbsoluteTo);
 
   if (!isDir(AbsoluteTo)) return false;
 
   relativePath = normalize(relativePath);
 
   while (!relativePath.compare(0, 3, "../"))
     {
       AbsoluteTo = dirName(AbsoluteTo);
       relativePath = relativePath.substr(3);
     }
 
   relativePath = AbsoluteTo + "/" + relativePath;
 
   return true;
 }

bool CDirEntry::makePathRelative	(	std::string &	absolutePath,
		const std::string &	relativeTo
	)

static

Makes the absolute path relative to the path given in relativeTo

Parameters

std::string	& absolutePath
const	std::string & relativeTo

Returns: bool success

Definition at line 434 of file CDirEntry.cpp.

References dirName(), isDir(), isFile(), isRelativePath(), min, and normalize().

Referenced by CCopasiXMLInterface::saveParameter(), CCopasiXML::saveSBMLReference(), and CCopasiXML::saveTaskList().

 {
   if (isRelativePath(absolutePath) ||
       isRelativePath(relativeTo)) return false; // Nothing can be done.
 
   std:: string RelativeTo = normalize(relativeTo);
 
   if (isFile(RelativeTo)) RelativeTo = dirName(RelativeTo);
 
   if (!isDir(RelativeTo)) return false;
 
   absolutePath = normalize(absolutePath);
 
   size_t i, imax = std::min(absolutePath.length(), RelativeTo.length());
 
   for (i = 0; i < imax; i++)
     if (absolutePath[i] != RelativeTo[i]) break;
 
   // We need to retract to the beginning of the current directory.
   if (i != imax)
     i = absolutePath.find_last_of('/', i) + 1;
 
 #ifdef WIN32
 
   if (i == 0) return false; // A different drive letter we cannot do anything
 
 #endif
 
   RelativeTo = RelativeTo.substr(i);
 
   std::string relativePath;
 
   while (RelativeTo != "")
     {
       relativePath += "../";
       RelativeTo = dirName(RelativeTo);
     }
 
   if (relativePath != "")
     absolutePath = relativePath + absolutePath.substr(i);
   else
     absolutePath = absolutePath.substr(i + 1);
 
   return true;
 }

bool CDirEntry::match	(	const std::string &	name,
		const std::vector< std::string > &	patternList
	)

static

Compare the name against the pattern list and returns whether the name matches. The patternList can be created from a pattern by the compilePattern method.

Parameters

const	std::string & name
const	std::vector< std::string > & patternList

Returns: bool match

Definition at line 398 of file CDirEntry.cpp.

References matchInternal().

Referenced by removeFiles().

 {
   std::vector< std::string >::const_iterator it = patternList.begin();
   std::vector< std::string >::const_iterator end = patternList.end();
   std::string::size_type at = 0;
   std::string::size_type after = 0;
 
   bool Match = true;
 
   while (it != end && Match)
     Match = matchInternal(name, *it++, at, after);
 
   return Match;
 }

bool CDirEntry::matchInternal	(	const std::string &	name,
		const std::string	pattern,
		std::string::size_type &	at,
		std::string::size_type &	after
	)

staticprivate

This private methods checks whether the active section matches the secified patter. The section is automatically advanced to allow repeated calls. On the first call 'at' must be 0. The parameters 'at' and 'after' must not be changed outside this method.

Parameters

const	std::string & name
const	std::string pattern
std::string::size_type	& at
std::string::size_type	& after

Returns: bool match

Definition at line 506 of file CDirEntry.cpp.

Referenced by match().

 {
   bool Match = true;
 
   switch (pattern[0])
     {
       case '*':
 
         if (at != std::string::npos)
           {
             after = at;
             at = std::string::npos;
           }
 
         break;
 
       case '?':
 
         if (at != std::string::npos)
           {
             ++at;
             Match = (name.length() >= at);
           }
         else
           {
             ++after;
             Match = (name.length() >= after);
           }
 
         break;
 
       default:
 
         if (at != std::string::npos)
           {
             Match = (name.compare(at, pattern.length(), pattern) == 0);
             at += pattern.length();
           }
         else
           {
             at = name.find(pattern, after);
             Match = (at != std::string::npos);
             at += pattern.length();
           }
 
         break;
     }
 
   return Match;
 }

bool CDirEntry::move	(	const std::string &	from,
		const std::string &	to
	)

static

Move a file from. If to is the directory the filename of from is appended.

Parameters

const	std::string & from
const	std::string & to

Returns: bool success

Definition at line 233 of file CDirEntry.cpp.

References exist(), fileName(), CLocaleString::fromUtf8(), isDir(), isFile(), and Separator.

Referenced by CCopasiDataModel::saveModel().

 {
   if (!isFile(from)) return false;
 
   std::string To = to;
 
   // Check whether To is a directory and append the
   // filename of from
   if (isDir(To))
     To += Separator + fileName(from);
 
   if (isDir(To)) return false;
 
 #ifdef WIN32
 
   // The target must not exist under WIN32 for rename to succeed.
   if (exist(To) && !remove(To))
     return false;
 
 #endif // WIN32
 
   bool success =
     (rename(CLocaleString::fromUtf8(from).c_str(), CLocaleString::fromUtf8(To).c_str()) == 0);
 
   if (!success)
     {
       {
         std::ifstream in(CLocaleString::fromUtf8(from).c_str());
         std::ofstream out(CLocaleString::fromUtf8(To).c_str());
 
         out << in.rdbuf();
 
         success = out.good();
       }
 
       remove(from);
     }
 
   return success;
 }

std::string CDirEntry::normalize ( const std::string & path )

static

This method normalizes the path, i.e., it converts all '\' to '/' (only on WIN32) and collapses '^./' to '^', '/./' to '/', and '[^/]+/../' to '/'

Parameters

const std::string & path

Returns: std::string normalizedPath

Definition at line 560 of file CDirEntry.cpp.

References COptions::getValue().

Referenced by CRecentFiles::addFile(), CCopasiDataModel::importSBML(), isRelativePath(), CCopasiDataModel::loadModel(), makePathAbsolute(), makePathRelative(), CCopasiDataModel::saveModel(), and CCopasiDataModel::setSBMLFileName().

 {
   std::string Normalized = path;
 
 #ifdef WIN32
   // converts all '\' to '/' (only on WIN32)
   size_t i, imax;
 
   for (i = 0, imax = Normalized.length(); i < imax; i++)
     if (Normalized[i] == '\\') Normalized[i] = '/';
 
   // if the path starts with /[^/] we prepend the current drive letter
   if (Normalized.length() > 0 && Normalized[0] == '/')
     {
       if ((Normalized.length() > 1 && Normalized[1] != '/') ||
           Normalized.length() == 1)
         {
           std::string PWD;
           COptions::getValue("PWD", PWD);
 
           Normalized = PWD.substr(0, 2) + Normalized;
         }
     }
 
 #endif
 
   // Remove leading './'
   while (!Normalized.compare(0, 2, "./"))
     Normalized = Normalized.substr(2);
 
   // Collapse '//' to '/'
   std::string::size_type pos = 1;
 
   while (true)
     {
       pos = Normalized.find("//", pos);
 
       if (pos == std::string::npos) break;
 
       Normalized.erase(pos, 1);
     }
 
   // Collapse '/./' to '/'
   pos = 0;
 
   while (true)
     {
       pos = Normalized.find("/./", pos);
 
       if (pos == std::string::npos) break;
 
       Normalized.erase(pos, 2);
     }
 
   // Collapse '[^/]+/../' to '/'
   std::string::size_type start = Normalized.length();
 
   while (true)
     {
       pos = Normalized.rfind("/../", start);
 
       if (pos == std::string::npos) break;
 
       start = Normalized.rfind('/', pos - 1);
 
       if (start == std::string::npos) break;
 
       if (!Normalized.compare(start, 4, "/../")) continue;
 
       Normalized.erase(start, pos - start + 3);
       start = Normalized.length();
     }
 
   return Normalized;
 }

bool CDirEntry::remove ( const std::string & path )

static

Removes a file or directory specified by path.

Parameters

const std::string & path

Returns: bool success

Definition at line 275 of file CDirEntry.cpp.

References CLocaleString::fromUtf8(), isDir(), and isFile().

Referenced by CopasiUI3Window::CleanUp(), CCopasiDataModel::saveModel(), and Copasi2SBMLTranslator::translate().

 {
   if (isDir(path))
     return (rmdir(CLocaleString::fromUtf8(path).c_str()) == 0);
   else if (isFile(path))
 #ifdef WIN32
     return (_wremove(CLocaleString::fromUtf8(path).c_str()) == 0);
 
 #else
     return (::remove(CLocaleString::fromUtf8(path).c_str()) == 0);
 #endif
 
   return false;
 }

bool CDirEntry::removeFiles	(	const std::string &	pattern,
		const std::string &	dir
	)

static

Remove files or directories matching the pattern in directory dir.

Parameters

const	std::string & pattern
const	std::string & dir

Returns: bool success

Definition at line 290 of file CDirEntry.cpp.

References compilePattern(), CLocaleString::fromUtf8(), isDir(), match(), Separator, and CLocaleString::toUtf8().

Referenced by CopasiUI3Window::CleanUp().

 {
   bool success = true;
   std::vector< std::string > PatternList;
 
   PatternList = compilePattern(pattern);
 
 #ifdef WIN32
 
   // We want the same pattern matching behaviour for all platforms.
   // Therefore, we do not use the MS provided one and list all files instead.
   std::string FilePattern = path + "\\*";
 
   // Open directory stream and try read info about first entry
   struct _wfinddata_t Entry;
   intptr_t hList = _wfindfirst(CLocaleString::fromUtf8(FilePattern).c_str(), &Entry);
 
   if (hList == -1) return success;
 
   do
     {
       std::string Utf8 = CLocaleString(Entry.name).toUtf8();
 
       if (match(Utf8, PatternList))
         {
           if (Entry.attrib | _A_NORMAL)
             {
 #ifdef WIN32
 
               if (_wremove(CLocaleString::fromUtf8(path + Separator + Utf8).c_str()) != 0) success = false;
 
 #else
 
               if (::remove(CLocaleString::fromUtf8(path + Separator + Utf8).c_str()) != 0) success = false;
 
 #endif
             }
           else
             {
               if (rmdir(CLocaleString::fromUtf8(path + Separator + Utf8).c_str()) != 0) success = false;
             }
         }
     }
   while (_wfindnext(hList, &Entry) == 0);
 
   _findclose(hList);
 
 #else
 
   DIR * pDir = opendir(CLocaleString::fromUtf8(path).c_str());
 
   if (!pDir) return false;
 
   struct dirent * pEntry;
 
   while ((pEntry = readdir(pDir)) != NULL)
     {
       std::string Utf8 = CLocaleString(pEntry->d_name).toUtf8();
 
       if (match(Utf8, PatternList))
         {
           if (isDir(Utf8))
             {
               if (rmdir(CLocaleString::fromUtf8(path + Separator + Utf8).c_str()) != 0)
                 success = false;
             }
           else
             {
               if (::remove(CLocaleString::fromUtf8(path + Separator + Utf8).c_str()) != 0)
                 success = false;
             }
         }
     }
 
   closedir(pDir);
 
 #endif // WIN32
 
   return success;
 }

std::string CDirEntry::suffix ( const std::string & path )

static

Returns the suffix, i.e., the directory path and the the base name are removed from 'path'.

Parameters

const std::string & path

Returns: std::string basename

Definition at line 159 of file CDirEntry.cpp.

References Separator.

Referenced by createTmpName(), CopasiFileDialog::getSaveFileName(), CCopasiDataModel::importSBML(), CCopasiDataModel::loadModel(), and CopasiUI3Window::slotFileOpenFinished().

 {
   std::string::size_type start = path.find_last_of(Separator);
 #ifdef WIN32 // WIN32 also understands '/' as the separator.
 
   if (start == std::string::npos)
     start = path.find_last_of("/");
 
 #endif
 
   if (start == std::string::npos) start = 0;
   else start++; // We do not want the separator.
 
   std::string::size_type end = path.find_last_of(".");
 
   if (end == std::string::npos || end < start)
     return "";
   else
     return path.substr(end);
 }

Member Data Documentation

const std::string CDirEntry::Separator = "/"

static

The character used to separate directory entries.

Definition at line 34 of file CDirEntry.h.

Referenced by CCopasiDataModel::autoSave(), baseName(), createDir(), createTmpName(), createUniqueModelFileName(), dirName(), CSEDMLExporter::exportModelAndTasks(), fileName(), COptions::getConfigDir(), COptions::getConfigFile(), COptions::getTemp(), SEDMLImporter::importFirstSBMLModel(), CCopasiDataModel::importSBML(), CConfigurationFile::load(), CCopasiDataModel::loadModel(), move(), removeFiles(), CopasiUI3Window::slotExportMathModel(), CopasiUI3Window::slotExportSBML(), and suffix().

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

Static Public Member Functions

Static Public Attributes

Static Private Member Functions

Detailed Description

Member Function Documentation

Member Data Documentation