cpp/galago/contrib/indri/src/Path.cpp

   1 /*==========================================================================
   2  * Copyright (c) 2004 University of Massachusetts.  All Rights Reserved.
   3  *
   4  * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
   5  * is subject to the terms of the software license set forth in the LICENSE
   6  * file included with this software, and also available at
   7  * http://www.lemurproject.org/license.html
   8  *
   9  *==========================================================================
  10  */
  11
  12
  13 //
  14 // Path.cpp
  15 //
  16 // 20 May 2004 -- tds
  17 //
  18
  19 #include <string>
  20 #include "indri/Path.hpp"
  21 #include "lemur/Exception.hpp"
  22 #include "lemur/lemur-compat.hpp"
  23 #include <sys/stat.h>
  24 #include <errno.h>
  25 #include <iostream>
  26 #include <stack>
  27 #include "indri/DirectoryIterator.hpp"
  28 #include "indri/delete_range.hpp"
  29 #include "indri/XMLNode.hpp"
  30 #include "indri/XMLReader.hpp"
  31
  32 #ifdef WIN32
  33 #define PATH_SEPARATOR '\\'
  34 #else
  35 #define PATH_SEPARATOR '/'
  36 #endif
  37
  38 static int path_last_separator( const std::string& path ) {
  39   int i;
  40
  41   // skip any trailing slashes
  42   for( i=path.size()-1; i>=0; i-- ) {
  43     if( path[i] != PATH_SEPARATOR )
  44       break;
  45   }
  46
  47   for( ; i>=0; i-- ) {
  48     if( path[i] == PATH_SEPARATOR )
  49       break;
  50   }
  51
  52   return i;
  53 }
  54
  55 void indri::file::Path::create( const std::string& path ) {
  56   if( lemur_compat::mkdir( path.c_str(), 0777 ) < 0 ) {
  57     if( errno == EACCES ) {
  58       LEMUR_THROW( LEMUR_IO_ERROR, "Couldn't create directory: '" + path + "' because of inadequate permissions." );
  59     } else if( errno == ENOENT ) {
  60       LEMUR_THROW( LEMUR_IO_ERROR, "Couldn't create directory: '" + path + "' because at least one of the parent directories does not exist." );
  61     } else if( errno == EEXIST ) {
  62       LEMUR_THROW( LEMUR_IO_ERROR, "Couldn't create directory: '" + path + "' because something already exists there." );
  63     }
  64   }
  65 }
  66
  67 void indri::file::Path::remove( const std::string& path ) {
  68   std::stack<indri::file::DirectoryIterator*> iterators;
  69   indri::utility::StackDeleter<indri::file::DirectoryIterator> sd( iterators );
  70   iterators.push( new indri::file::DirectoryIterator( path ) );
  71
  72   while( iterators.size() ) {
  73     indri::file::DirectoryIterator* top = iterators.top();
  74
  75     // all done, so go up a level
  76     if( (*top) == indri::file::DirectoryIterator::end() ) {
  77       // release any search handles that may point
  78       // to this directory
  79       top->close();
  80
  81       int result = rmdir( top->base().c_str() );
  82       if( result != 0 )
  83         LEMUR_THROW( LEMUR_IO_ERROR, "indri::file::Path::remove couldn't remove directory '" + top->base() + "'." );
  84
  85       delete top;
  86       iterators.pop();
  87       continue;
  88     }
  89
  90     std::string path = **top;
  91     (*top)++;
  92
  93     if( indri::file::Path::isFile( path ) ) {
  94       int result = lemur_compat::remove( path.c_str() );
  95       if( result != 0 )
  96         LEMUR_THROW( LEMUR_IO_ERROR, "indri::file::Path::remove couldn't remove file '" + path + "'." );
  97     } else {
  98       iterators.push( new indri::file::DirectoryIterator( path ) );
  99     }
 100   }
 101 }
 102
 103 std::string indri::file::Path::trim( const std::string& path ) {
 104   if( path.size() && path[path.length()-1] == PATH_SEPARATOR ) {
 105     return path.substr( 0, path.length()-1 );
 106   }
 107
 108   return path;
 109 }
 110
 111 std::string indri::file::Path::relative( const std::string& basePath, const std::string absolutePath ) {
 112   std::string relativePath = absolutePath.substr( basePath.length() );
 113
 114   while( relativePath.length() && relativePath[0] == PATH_SEPARATOR )
 115     relativePath = relativePath.substr(1);
 116
 117   return relativePath;
 118 }
 119
 120 void indri::file::Path::make( const std::string& path ) {
 121   if( !indri::file::Path::isDirectory( path ) ) {
 122     std::string parent = indri::file::Path::directory( path );
 123     if( path == parent )
 124       return;
 125
 126     indri::file::Path::make( parent );
 127   }
 128
 129   lemur_compat::mkdir( path.c_str(), 0755 );
 130 }
 131
 132 char indri::file::Path::pathSeparator() {
 133   return PATH_SEPARATOR;
 134 }
 135
 136 bool indri::file::Path::isDirectory( const std::string& path ) {
 137   struct stat s;
 138   int result = stat( path.c_str(), &s );
 139   bool actualDirectory = (result >= 0) && (s.st_mode & S_IFDIR);
 140
 141   return actualDirectory;
 142 }
 143
 144 bool indri::file::Path::exists( const std::string& path ) {
 145   struct stat s;
 146   return stat( path.c_str(), &s ) >= 0;
 147 }
 148
 149 bool indri::file::Path::isFile( const std::string& path ) {
 150   struct stat s;
 151   int result = stat( path.c_str(), &s );
 152   bool actualFile = (result >= 0) && (s.st_mode & S_IFREG);
 153
 154   return actualFile;
 155 }
 156
 157 std::string indri::file::Path::combine( const std::string& root, const std::string& addition ) {
 158   if( !root.size() )
 159     return addition;
 160
 161   if( *(root.end()-1) == PATH_SEPARATOR )
 162     return root + addition;
 163
 164   return root + PATH_SEPARATOR + addition;
 165 }
 166
 167 std::string indri::file::Path::directory( const std::string& path ) {
 168   int last = path_last_separator( path );
 169
 170   if( last > 0 ) {
 171     return path.substr( 0, last );
 172   }
 173
 174   return path;
 175 }
 176
 177 std::string indri::file::Path::filename( const std::string& path ) {
 178   int last = path_last_separator( path );
 179
 180   if( last != std::string::npos ) {
 181     return path.substr( last+1 );
 182   }
 183
 184   return path;
 185 }
 186
 187 std::string indri::file::Path::extension( const std::string& path ) {
 188   int last = path_last_separator( path );
 189   std::string::size_type lastDot = path.find_last_of( '.' );
 190
 191   if( int(lastDot) > last ) {
 192     return path.substr( lastDot+1 );
 193   }
 194
 195   return std::string();
 196 }
 197
 198 std::string indri::file::Path::basename( const std::string& path ) {
 199   int last = path_last_separator( path );
 200   std::string::size_type lastDot = path.find_last_of( '.' );
 201
 202   if( int(lastDot) > last ) {
 203     return path.substr( 0, lastDot );
 204   }
 205
 206   return path;
 207 }
 208
 209