(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.25 and 1.40

version 1.25, 2001/06/16 17:30:37 version 1.40, 2002/09/11 19:11:54
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 23 
Line 24 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: // Modified By:
   //         Ramnath Ravindran(Ramnath.Ravindran@compaq.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 32 
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 75 
Line 70 
 Boolean FileSystem::existsNoCase(const String& path, String& realPath) Boolean FileSystem::existsNoCase(const String& path, String& realPath)
 { {
     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 100 
Line 95 
  
     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;
         }         }
Line 119 
Line 114 
  
 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 150 
Line 141 
     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);
  
     array.reserve(fileSize);      array.reserveCapacity(fileSize);
     char buffer[4096];     char buffer[4096];
     size_t n;     size_t n;
  
Line 184 
Line 173 
     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 223 
Line 208 
     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(
       const String& fromPath,
       const String& toPath)
   {
       return System::copyFile(fromPath.getCString(), toPath.getCString());
 } }
  
 Boolean FileSystem::openNoCase(PEGASUS_STD(ifstream)& is, const String& path) Boolean FileSystem::openNoCase(PEGASUS_STD(ifstream)& is, const String& path)
Line 235 
Line 225 
     if (!existsNoCase(path, realPath))     if (!existsNoCase(path, realPath))
         return false;         return false;
  
     ArrayDestroyer<char> p(_clonePath(path));      is.open(_clonePath(realPath) PEGASUS_IOS_BINARY);
       return !!is;
   }
   
   Boolean FileSystem::openNoCase(
       PEGASUS_STD(fstream)& fs,
       const String& path,
       int mode)
   {
       String realPath;
  
     is.open(p.getPointer() PEGASUS_IOS_BINARY);      if (!existsNoCase(path, realPath))
     return is != 0;          return false;
   
       fs.open(_clonePath(realPath), mode);
       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 352 
Line 350 
  
 void FileSystem::translateSlashes(String& path) void FileSystem::translateSlashes(String& path)
 { {
     for (Char16* p = (Char16*)path.getData(); *p; p++)      for (Uint32 i = 0; i < path.size(); i++)
     {     {
         if (*p == '\\')          if (path[i] == '\\')
             *p = '/';              path[i] = '/';
       }
     }     }
   
   Boolean GetLine(PEGASUS_STD(istream)& is, String& line)
   {
       line.clear();
   
       Boolean gotChar = false;
       char c;
   
       while (is.get(c))
       {
           gotChar = true;
   
           if (c == '\n')
               break;
   
           line.append(c);
       }
   
       return gotChar;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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