(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.4 and 1.35

version 1.4, 2001/02/26 04:33:28 version 1.35, 2002/07/17 22:46:55
Line 1 
Line 1 
 //BEGIN_LICENSE  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 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  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //END_LICENSE  //==============================================================================
 //BEGIN_HISTORY  
 // //
 // Author:  // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // $Log$  // Modified By:
 // Revision 1.4  2001/02/26 04:33:28  mike  //         Ramnath Ravindran(Ramnath.Ravindran@compaq.com)
 // Fixed many places where cim names were be compared with operator==(String,String).  
 // Changed all of these to use CIMName::equal()  
 // //
 // Revision 1.3  2001/02/13 02:06:40  mike  //%/////////////////////////////////////////////////////////////////////////////
 // Added renameFile() method.  
 //  
 // Revision 1.2  2001/02/11 05:42:33  mike  
 // new  
 //  
 // Revision 1.1.1.1  2001/01/14 19:51:35  mike  
 // Pegasus import  
 //  
 //  
 //END_HISTORY  
  
 #include <Pegasus/Common/Config.h>  #include <iostream>
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
 # include <io.h>  
 # include <direct.h>  
 #else  
 # include <unistd.h>  
 # include <dirent.h>  
 #endif  
   
 #include <sys/stat.h>  
 #include <sys/types.h>  
 #include <cstdio> #include <cstdio>
   #include <Pegasus/Common/Config.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"
  
 // ATTN-B: porting!  
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  // Clone the path as a C String but discard trailing slash if any:
 static const int ACCESS_EXISTS = 0;  
 static const int ACCESS_WRITE = 2;  
 static const int ACCESS_READ = 4;  
 static const int ACCESS_READ_AND_WRITE = 6;  
 #endif  
   
 // Clone the path but discard trailing slash if any:  
  
 static char* _clonePath(const String& path) static char* _clonePath(const String& path)
 { {
Line 76 
Line 48 
     if (!*p)     if (!*p)
         return p;         return p;
  
     char* last = p + path.getLength() - 1;      char* last = p + path.size() - 1;
  
     if (*last == '/')     if (*last == '/')
         *last = '\0';         *last = '\0';
Line 86 
Line 58 
  
 Boolean FileSystem::exists(const String& path) Boolean FileSystem::exists(const String& path)
 { {
     Destroyer<char> p(_clonePath(path));      ArrayDestroyer<char> p(_clonePath(path));
       return System::exists(p.getPointer());
   }
  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  Boolean FileSystem::getCurrentDirectory(String& path)
     return _access(p.getPointer(), ACCESS_EXISTS) == 0;  {
 #else      path.clear();
     return access(p.getPointer(), F_OK) == 0;      char tmp[4096];
 #endif  
       if (!System::getCurrentDirectory(tmp, sizeof(tmp) - 1))
           return false;
   
       path.append(tmp);
       return true;
 } }
  
 Boolean FileSystem::existsIgnoreCase(const String& path, String& realPath)  Boolean FileSystem::existsNoCase(const String& path, String& realPath)
 { {
     realPath.clear();     realPath.clear();
     Destroyer<char> destroyer(_clonePath(path));      ArrayDestroyer<char> destroyer(_clonePath(path));
     char* p = destroyer.getPointer();     char* p = destroyer.getPointer();
  
     char* dirPath;      const char* dirPath;
     char* fileName;     char* fileName;
     char* slash = strrchr(p, '/');     char* slash = strrchr(p, '/');
  
Line 110 
Line 89 
         *slash = '\0';         *slash = '\0';
         fileName = slash + 1;         fileName = slash + 1;
         dirPath = p;         dirPath = p;
   
         if (*fileName == '\0')         if (*fileName == '\0')
             return false;             return false;
     }     }
Line 119 
Line 99 
         dirPath = ".";         dirPath = ".";
     }     }
  
   
     for (Dir dir(dirPath); dir.more(); dir.next())     for (Dir dir(dirPath); dir.more(); dir.next())
     {     {
 #ifdef PEGASUS_OS_TYPE_WINDOWS          if (CompareNoCase(fileName, dir.getName()) == 0)
         if (stricmp(fileName, dir.getName()) == 0)  
 #else  
         if (strcasecmp(fileName, dir.getName()) == 0)  
 #endif  
         {         {
             if (strcmp(dirPath, ".") == 0)             if (strcmp(dirPath, ".") == 0)
                 realPath = dir.getName();                 realPath = dir.getName();
Line 144 
Line 121 
  
 Boolean FileSystem::canRead(const String& path) Boolean FileSystem::canRead(const String& path)
 { {
     Destroyer<char> p(_clonePath(path));      ArrayDestroyer<char> p(_clonePath(path));
       return System::canRead(p.getPointer());
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
     return _access(p.getPointer(), ACCESS_READ) == 0;  
 #else  
     return access(p.getPointer(), R_OK) == 0;  
 #endif  
 } }
  
 Boolean FileSystem::canWrite(const String& path) Boolean FileSystem::canWrite(const String& path)
 { {
     Destroyer<char> p(_clonePath(path));      ArrayDestroyer<char> p(_clonePath(path));
       return System::canWrite(p.getPointer());
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
     return _access(p.getPointer(), ACCESS_WRITE) == 0;  
 #else  
     return access(p.getPointer(), W_OK) == 0;  
 #endif  
 }  
   
 #if 0  
 // ATTN: not implemented for NT. But not used by Pegasus.  
 Boolean FileSystem::canExecute(const String& path)  
 {  
     Destroyer<char> p(_clonePath(path));  
     return access(p.getPointer(), X_OK) == 0;  
 }  
 #endif  
   
 Boolean FileSystem::isDirectory(const String& path)  
 {  
     Destroyer<char> p(_clonePath(path));  
   
     struct stat st;  
   
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
   
     if (stat(p.getPointer(), &st) != 0)  
         return false;  
   
     Boolean result = (st.st_mode & _S_IFDIR) != 0;  
     return result;  
   
 #else  
   
     if (stat(p.getPointer(), &st) != 0)  
         return false;  
   
     Boolean result = S_ISDIR(st.st_mode);  
     return result;  
   
 #endif  
 }  
   
 Boolean FileSystem::changeDirectory(const String& path)  
 {  
     Destroyer<char> p(_clonePath(path));  
     return chdir(p.getPointer()) == 0;  
 }  
   
 Boolean FileSystem::makeDirectory(const String& path)  
 {  
     Destroyer<char> p(_clonePath(path));  
 #ifdef PEGASUS_OS_TYPE_WINDOWS  
     return _mkdir(p.getPointer()) == 0;  
 #else  
     return mkdir(p.getPointer(), 0777) == 0;  
 #endif  
 } }
  
 Boolean FileSystem::getFileSize(const String& path, Uint32& size) Boolean FileSystem::getFileSize(const String& path, Uint32& size)
 { {
     struct stat st;      ArrayDestroyer<char> p(_clonePath(path));
       return System::getFileSize(p.getPointer(), size);
     Destroyer<char> p(_clonePath(path));  
   
     if (stat(p.getPointer(), &st) != 0)  
         return false;  
   
     size = st.st_size;  
     return true;  
 }  
   
 Boolean FileSystem::removeDirectory(const String& path)  
 {  
     Destroyer<char> p(_clonePath(path));  
     return rmdir(p.getPointer()) == 0;  
 } }
  
 Boolean FileSystem::removeFile(const String& path) Boolean FileSystem::removeFile(const String& path)
 { {
     Destroyer<char> p(_clonePath(path));      ArrayDestroyer<char> p(_clonePath(path));
     return unlink(p.getPointer()) == 0;      return System::removeFile(p.getPointer());
 } }
  
 void FileSystem::loadFileToMemory( void FileSystem::loadFileToMemory(
Line 265 
Line 169 
     fclose(fp);     fclose(fp);
 } }
  
 Boolean FileSystem::compare(  Boolean FileSystem::compareFiles(
     const String& fileName1,      const String& path1,
     const String& fileName2)      const String& path2)
 { {
     Uint32 fileSize1;     Uint32 fileSize1;
  
     if (!getFileSize(fileName1, fileSize1))      if (!getFileSize(path1, fileSize1))
         throw CannotOpenFile(fileName1);          throw CannotOpenFile(path1);
  
     Uint32 fileSize2;     Uint32 fileSize2;
  
     if (!getFileSize(fileName2, fileSize2))      if (!getFileSize(path2, fileSize2))
         throw CannotOpenFile(fileName2);          throw CannotOpenFile(path2);
  
     if (fileSize1 != fileSize2)     if (fileSize1 != fileSize2)
         return false;         return false;
  
     char* tmp1 = fileName1.allocateCString();      char* tmp1 = path1.allocateCString();
     FILE* fp1 = fopen(tmp1, "rb");     FILE* fp1 = fopen(tmp1, "rb");
     delete [] tmp1;     delete [] tmp1;
  
     if (fp1 == NULL)     if (fp1 == NULL)
         throw CannotOpenFile(fileName1);          throw CannotOpenFile(path1);
  
     char* tmp2 = fileName2.allocateCString();      char* tmp2 = path2.allocateCString();
     FILE* fp2 = fopen(tmp2, "rb");     FILE* fp2 = fopen(tmp2, "rb");
     delete [] tmp2;     delete [] tmp2;
  
     if (fp2 == NULL)     if (fp2 == NULL)
     {     {
         fclose(fp1);         fclose(fp1);
         throw CannotOpenFile(fileName2);          throw CannotOpenFile(path2);
     }     }
  
     int c1;     int c1;
Line 317 
Line 221 
     return true;     return true;
 } }
  
   Boolean FileSystem::renameFile(
       const String& oldPath,
       const String& newPath)
   {
       ArrayDestroyer<char> p(oldPath.allocateCString());
       ArrayDestroyer<char> q(newPath.allocateCString());
       return System::renameFile(p.getPointer(), q.getPointer());
   }
   
   Boolean FileSystem::copyFile(
       const String& fromPath,
       const String& toPath)
   {
       ArrayDestroyer<char> p(fromPath.allocateCString());
       ArrayDestroyer<char> q(toPath.allocateCString());
       return System::copyFile(p.getPointer(), q.getPointer());
   }
   
   Boolean FileSystem::openNoCase(PEGASUS_STD(ifstream)& is, const String& path)
   {
       String realPath;
   
       if (!existsNoCase(path, realPath))
           return false;
   
       ArrayDestroyer<char> p(_clonePath(realPath));
   
       is.open(p.getPointer() PEGASUS_IOS_BINARY);
       return !!is;
   }
   
   Boolean FileSystem::openNoCase(
       PEGASUS_STD(fstream)& fs,
       const String& path,
       int mode)
   {
       String realPath;
   
       if (!existsNoCase(path, realPath))
           return false;
   
       ArrayDestroyer<char> p(_clonePath(realPath));
   
       fs.open(p.getPointer(), mode);
       return !!fs;
   }
   
   Boolean FileSystem::isDirectory(const String& path)
   {
       ArrayDestroyer<char> p(_clonePath(path));
       return System::isDirectory(p.getPointer());
   }
   
   Boolean FileSystem::changeDirectory(const String& path)
   {
       ArrayDestroyer<char> p(_clonePath(path));
       return System::changeDirectory(p.getPointer());
   }
   
   Boolean FileSystem::makeDirectory(const String& path)
   {
       ArrayDestroyer<char> p(_clonePath(path));
       return System::makeDirectory(p.getPointer());
   }
   
   Boolean FileSystem::removeDirectory(const String& path)
   {
       ArrayDestroyer<char> p(_clonePath(path));
       return System::removeDirectory(p.getPointer());
   }
   
   Boolean FileSystem::removeDirectoryHier(const String& path)
   {
       Array<String> fileList;
   
       // Get contents of current directory
   
       if (!FileSystem::getDirectoryContents(path,fileList))
           return false;
   
       // for files-in-directory, delete or recall removedir
   
       for (Uint32 i = 0, n = fileList.size(); i < n; i++)
       {
           String newPath = path;   // extend path to subdir
           newPath.append("/");
           newPath.append(fileList[i]);
   
           if (FileSystem::isDirectory(newPath))
           {
               // Recall ourselves with extended path
               if (!FileSystem::removeDirectoryHier(newPath))
                   return false;
           }
   
           else
           {
             if (!FileSystem::removeFile(newPath))
                   return false;
           }
       }
   
       return removeDirectory(path);
   }
   
   //
   //  Get the file list in the directory into the
   //  array of strings provided
   //  @return The function should return false under these circumstances:
   //
   //
   //  1. The directory does not exist.
   //  2. The file exists but is not a directory.
   //  3. The directory is inaccessible.
   //
   //
 Boolean FileSystem::getDirectoryContents( Boolean FileSystem::getDirectoryContents(
     const String& path,     const String& path,
     Array<String>& paths)     Array<String>& paths)
 { {
     paths.clear();     paths.clear();
  
       try
       {
     for (Dir dir(path); dir.more(); dir.next())     for (Dir dir(path); dir.more(); dir.next())
     {     {
         String name = dir.getName();         String name = dir.getName();
Line 332 
Line 354 
  
         paths.append(name);         paths.append(name);
     }     }
           return true;
       }
   
       // Catch the Dir exception
       catch(CannotOpenDirectory&)
       {
           return false;
       }
   }
   
   Boolean FileSystem::isDirectoryEmpty(const String& path)
   {
       for (Dir dir(path); dir.more(); dir.next())
       {
           const char* name = dir.getName();
   
           if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0)
               return false;
       }
  
     return true;     return true;
 } }
  
 Boolean FileSystem::renameFile(  void FileSystem::translateSlashes(String& path)
     const String& oldFileName,  {
     const String& newFileName)      for (Uint32 i = 0; i < path.size(); i++)
       {
           if (path[i] == '\\')
               path[i] = '/';
       }
   }
   
   Boolean GetLine(PEGASUS_STD(istream)& is, String& line)
 { {
     Destroyer<char> p(oldFileName.allocateCString());      line.clear();
     Destroyer<char> q(newFileName.allocateCString());  
       Boolean gotChar = false;
       char c;
   
       while (is.get(c))
       {
           gotChar = true;
   
           if (c == '\n')
               break;
   
           line.append(c);
       }
  
 #ifdef PEGASUS_OS_TYPE_WINDOWS      return gotChar;
     return rename(p.getPointer(), q.getPointer()) == 0;  
 #else  
     return link(p.getPointer(), q.getPointer()) == 0;  
 #endif  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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