(file) Return to FileSystem.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/FileSystem.cpp between version 1.40.2.1 and 1.43.6.1

version 1.40.2.1, 2002/10/28 15:43:21 version 1.43.6.1, 2003/08/13 19:39:50
Line 34 
Line 34 
 #include <Pegasus/Common/System.h> #include <Pegasus/Common/System.h>
 #include "Destroyer.h" #include "Destroyer.h"
 #include "FileSystem.h" #include "FileSystem.h"
 #include "System.h"  
 #include "Dir.h" #include "Dir.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // Clone the path as a C String but discard trailing slash if any: // Clone the path as a C String but discard trailing slash if any:
  
 static char* _clonePath(const String& path)  static CString _clonePath(const String& path)
 { {
     char* p = path.allocateCString();      String clone = path;
  
     if (!*p)      if (clone.size() && clone[clone.size()-1] == '/')
         return p;          clone.remove(clone.size()-1);
  
     char* last = p + path.size() - 1;      return clone.getCString();
   
     if (*last == '/')  
         *last = '\0';  
   
     return p;  
 } }
  
 Boolean FileSystem::exists(const String& path) Boolean FileSystem::exists(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::exists(_clonePath(path));
     return System::exists(p.getPointer());  
 } }
  
 Boolean FileSystem::getCurrentDirectory(String& path) Boolean FileSystem::getCurrentDirectory(String& path)
Line 76 
Line 69 
  
 Boolean FileSystem::existsNoCase(const String& path, String& realPath) Boolean FileSystem::existsNoCase(const String& path, String& realPath)
 { {
   #ifdef PEGASUS_OS_OS400
       // The OS/400 file system is case insensitive, so just call exists( ).
       // This is faster, but the main reason to do this is to
       // avoid multi-threading problems with the IFS directory APIs
       // (even though they claim to be threadsafe).
       realPath = path;
       return exists(path);
   #else
     realPath.clear();     realPath.clear();
     ArrayDestroyer<char> destroyer(_clonePath(path));      CString cpath = _clonePath(path);
     char* p = destroyer.getPointer();      const char* p = cpath;
  
     const char* dirPath;     const char* dirPath;
     char* fileName;      const char* fileName;
     char* slash = strrchr(p, '/');      char* slash = (char *) strrchr(p, '/');
  
     if (slash)     if (slash)
     {     {
Line 102 
Line 103 
  
     for (Dir dir(dirPath); dir.more(); dir.next())     for (Dir dir(dirPath); dir.more(); dir.next())
     {     {
         if (CompareNoCase(fileName, dir.getName()) == 0)          if (System::strcasecmp(fileName, dir.getName()) == 0)
         {         {
             if (strcmp(dirPath, ".") == 0)             if (strcmp(dirPath, ".") == 0)
                 realPath = dir.getName();                 realPath = dir.getName();
             else             else
             {             {
                 realPath = dirPath;                 realPath = dirPath;
                 realPath += '/';                  realPath.append('/');
                 realPath += dir.getName();                  realPath.append(dir.getName());
             }             }
             return true;             return true;
         }         }
     }     }
  
     return false;     return false;
   #endif
 } }
  
 Boolean FileSystem::canRead(const String& path) Boolean FileSystem::canRead(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::canRead(_clonePath(path));
     return System::canRead(p.getPointer());  
 } }
  
 Boolean FileSystem::canWrite(const String& path) Boolean FileSystem::canWrite(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::canWrite(_clonePath(path));
     return System::canWrite(p.getPointer());  
 } }
  
 Boolean FileSystem::getFileSize(const String& path, Uint32& size) Boolean FileSystem::getFileSize(const String& path, Uint32& size)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::getFileSize(_clonePath(path), size);
     return System::getFileSize(p.getPointer(), size);  
 } }
  
 Boolean FileSystem::removeFile(const String& path) Boolean FileSystem::removeFile(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::removeFile(_clonePath(path));
     return System::removeFile(p.getPointer());  
 } }
  
 void FileSystem::loadFileToMemory( void FileSystem::loadFileToMemory(
Line 152 
Line 150 
     if (!getFileSize(fileName, fileSize))     if (!getFileSize(fileName, fileSize))
         throw CannotOpenFile(fileName);         throw CannotOpenFile(fileName);
  
     char* tmp = fileName.allocateCString();      FILE* fp = fopen(fileName.getCString(), "rb");
     FILE* fp = fopen(tmp, "rb");  
     delete [] tmp;  
  
     if (fp == NULL)     if (fp == NULL)
         throw CannotOpenFile(fileName);         throw CannotOpenFile(fileName);
Line 186 
Line 182 
     if (fileSize1 != fileSize2)     if (fileSize1 != fileSize2)
         return false;         return false;
  
     char* tmp1 = path1.allocateCString();      FILE* fp1 = fopen(path1.getCString(), "rb");
     FILE* fp1 = fopen(tmp1, "rb");  
     delete [] tmp1;  
  
     if (fp1 == NULL)     if (fp1 == NULL)
         throw CannotOpenFile(path1);         throw CannotOpenFile(path1);
  
     char* tmp2 = path2.allocateCString();      FILE* fp2 = fopen(path2.getCString(), "rb");
     FILE* fp2 = fopen(tmp2, "rb");  
     delete [] tmp2;  
  
     if (fp2 == NULL)     if (fp2 == NULL)
     {     {
Line 225 
Line 217 
     const String& oldPath,     const String& oldPath,
     const String& newPath)     const String& newPath)
 { {
     ArrayDestroyer<char> p(oldPath.allocateCString());      return System::renameFile(oldPath.getCString(), newPath.getCString());
     ArrayDestroyer<char> q(newPath.allocateCString());  
     return System::renameFile(p.getPointer(), q.getPointer());  
 } }
  
 Boolean FileSystem::copyFile( Boolean FileSystem::copyFile(
     const String& fromPath,     const String& fromPath,
     const String& toPath)     const String& toPath)
 { {
     ArrayDestroyer<char> p(fromPath.allocateCString());      return System::copyFile(fromPath.getCString(), toPath.getCString());
     ArrayDestroyer<char> q(toPath.allocateCString());  
     return System::copyFile(p.getPointer(), q.getPointer());  
 } }
  
 Boolean FileSystem::openNoCase(PEGASUS_STD(ifstream)& is, const String& path) Boolean FileSystem::openNoCase(PEGASUS_STD(ifstream)& is, const String& path)
Line 246 
Line 234 
     if (!existsNoCase(path, realPath))     if (!existsNoCase(path, realPath))
         return false;         return false;
  
     ArrayDestroyer<char> p(_clonePath(realPath));  #if defined(PEGASUS_OS_OS400)
       CString tempPath = _clonePath(realPath);
       const char * tmp = tempPath;
       AtoE((char *)tmp);
       is.open(tmp PEGASUS_IOS_BINARY);
   #else
       is.open(_clonePath(realPath) PEGASUS_IOS_BINARY);
   #endif
  
     is.open(p.getPointer() PEGASUS_IOS_BINARY);  
     return !!is;     return !!is;
 } }
  
Line 261 
Line 255 
  
     if (!existsNoCase(path, realPath))     if (!existsNoCase(path, realPath))
         return false;         return false;
   #if defined(__GNUC__) && GCC_VERSION >= 30200
     ArrayDestroyer<char> p(_clonePath(realPath));      fs.open(_clonePath(realPath), PEGASUS_STD(ios_base::openmode)(mode));
   #else
     fs.open(p.getPointer(), mode);  #if defined(PEGASUS_OS_OS400)
       CString tempPath = _clonePath(realPath);
       const char * tmp = tempPath;
       AtoE((char *)tmp);
       fs.open(tmp, mode, PEGASUS_STD(_CCSID_T(1208)) );
   #else
       fs.open(_clonePath(realPath), mode);
   #endif
   #endif
     return !!fs;     return !!fs;
 } }
  
 Boolean FileSystem::isDirectory(const String& path) Boolean FileSystem::isDirectory(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::isDirectory(_clonePath(path));
     return System::isDirectory(p.getPointer());  
 } }
  
 Boolean FileSystem::changeDirectory(const String& path) Boolean FileSystem::changeDirectory(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::changeDirectory(_clonePath(path));
     return System::changeDirectory(p.getPointer());  
 } }
  
 Boolean FileSystem::makeDirectory(const String& path) Boolean FileSystem::makeDirectory(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::makeDirectory(_clonePath(path));
     return System::makeDirectory(p.getPointer());  
 } }
  
 Boolean FileSystem::removeDirectory(const String& path) Boolean FileSystem::removeDirectory(const String& path)
 { {
     ArrayDestroyer<char> p(_clonePath(path));      return System::removeDirectory(_clonePath(path));
     return System::removeDirectory(p.getPointer());  
 } }
  
 Boolean FileSystem::removeDirectoryHier(const String& path) Boolean FileSystem::removeDirectoryHier(const String& path)
Line 386 
Line 384 
     }     }
 } }
  
   // Return the just the base name from the path.
   String  FileSystem::extractFileName(const String& path)
   {
     char *p_path = new char[path.size() + 1];
     String basename = System::extract_file_name((const char *)path.getCString(), p_path);
   
     delete [] p_path;
   
     return basename;
   }
   
   // Return just the path to the file or directory into path
   String FileSystem::extractFilePath(const String& path)
   {
     char *p_path = new char[path.size() + 1];
     String newpath = System::extract_file_path((const char *)path.getCString(), p_path);
   
     delete [] p_path;
   
     return newpath;
   }
   
   
 Boolean GetLine(PEGASUS_STD(istream)& is, String& line) Boolean GetLine(PEGASUS_STD(istream)& is, String& line)
 { {
     line.clear();     line.clear();

Legend:
Removed from v.1.40.2.1  
changed lines
  Added in v.1.43.6.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2