FilePath.cpp

/*
 * FilePath.cpp
 *
 * Copyright (C) 2009-11 by RStudio, Inc.
 *
 * This program is licensed to you under the terms of version 3 of the
 * GNU Affero General Public License. This program is distributed WITHOUT
 * ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
 * AGPL (http://www.gnu.org/licenses/agpl-3.0.txt) for more details.
 *
 */

#include <core/FilePath.hpp>

#include <algorithm>
#include <fstream>

#ifdef _WIN32
#include <windows.h>
#endif

#include <boost/version.hpp>
#if BOOST_VERSION >= 104400
#define BOOST_FILESYSTEM_VERSION 3
#endif
#define BOOST_FILESYSTEM_NARROW_ONLY
#define BOOST_FILESYSTEM2_NARROW_ONLY
#define BOOST_FILESYSTEM_NO_DEPRECATED
#include <boost/filesystem.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/file_descriptor.hpp>

#include <core/StringUtils.hpp>
#include <core/system/System.hpp>

#include <core/Log.hpp>
#include <core/Error.hpp>


typedef boost::filesystem::path path_t;

namespace core {

namespace {

// We use boost::filesystem in one of three different ways:
// - On Windows, we use Filesystem v3 with wide character paths. This is
//   because narrow character paths on Windows can't cover the entire
//   Unicode space since there is no ANSI code page for UTF-8.
// - On non-Windows, if Filesystem v3 is available, we use it.
// - Otherwise, we use Filesystem v2. This is necessary for older versions
//   of Boost that come preinstalled on some long-term-stable Linux distro
//   versions that we still want to support.
#ifdef _WIN32

#define BOOST_FS_STRING(path) toString((path).generic_wstring())
#define BOOST_FS_PATH2STR(path) toString((path).generic_wstring())
#define BOOST_FS_COMPLETE(p, base) boost::filesystem::absolute(fromString(p), base)
typedef boost::filesystem::directory_iterator dir_iterator;
typedef boost::filesystem::recursive_directory_iterator recursive_dir_iterator;

#elif defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION != 2

#define BOOST_FS_STRING(path) ((path).generic_string())
#define BOOST_FS_PATH2STR(path) ((path).generic_string())
#define BOOST_FS_COMPLETE(p, base) boost::filesystem::absolute(p, base)
typedef boost::filesystem::directory_iterator dir_iterator;
typedef boost::filesystem::recursive_directory_iterator recursive_dir_iterator;

#else

#define BOOST_FS_STRING(str) (str)
#define BOOST_FS_PATH2STR(str) ((str).string())
#define BOOST_FS_COMPLETE(p, base) boost::filesystem::complete(p, base)
typedef boost::filesystem::basic_directory_iterator<path_t> dir_iterator;
typedef boost::filesystem::basic_recursive_directory_iterator<path_t> recursive_dir_iterator;

#endif



#ifdef _WIN32

// For Windows only, we need to use the wide character versions of the file
// APIs in order to deal properly with characters that cannot be represented
// in the default system encoding. (It would be preferable if UTF-8 were the
// system encoding, but Windows doesn't support that.) However, we can't give
// FilePath a wide character API because Mac needs to use narrow characters
// (see note below). So we use wstring internally, and translate to/from UTF-8
// narrow strings that are used in the API.

typedef std::wstring internal_string;

std::string toString(const internal_string& value)
{
   if (value.size() == 0)
      return std::string();

   const wchar_t * cstr = value.c_str();
   int chars = ::WideCharToMultiByte(CP_UTF8, 0,
                                     cstr, -1,
                                     NULL, 0, NULL, NULL);
   if (chars == 0)
   {
      LOG_ERROR(systemError(::GetLastError(), ERROR_LOCATION));
      return std::string();
   }

   std::vector<char> result(chars, 0);
   chars = ::WideCharToMultiByte(CP_UTF8, 0,
                                 cstr, -1,
                                 &(result[0]), result.size(),
                                 NULL, NULL);

   return std::string(&(result[0]));
}

internal_string fromString(const std::string& value)
{
   if (value.size() == 0)
      return std::wstring();

   const char * cstr = value.c_str();
   int chars = ::MultiByteToWideChar(CP_UTF8, 0,
                                     cstr, -1,
                                     NULL, 0);
   if (chars == 0)
   {
      LOG_ERROR(systemError(::GetLastError(), ERROR_LOCATION));
      return std::wstring();
   }

   std::vector<wchar_t> result(chars, 0);
   chars = ::MultiByteToWideChar(CP_UTF8, 0,
                                 cstr, -1,
                                 &(result[0]), result.size());

   return std::wstring(&(result[0]));
}

#else

// We only support running with UTF-8 codeset on Mac and Linux, so
// strings are a passthrough.

typedef std::string internal_string;

internal_string fromString(const std::string& value)
{
   return value;
}

#endif

void logError(path_t path,
              const boost::filesystem::filesystem_error& e,
              const ErrorLocation& errorLocation);
void addErrorProperties(path_t path, Error* pError) ;
}

struct FilePath::Impl
{
   Impl()
   {
   }
   Impl(path_t path)
      : path(path)
   {
   }
   path_t path ;
};
  
FilePath FilePath::safeCurrentPath(const FilePath& revertToPath)
{
   try
   {
#if defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION != 2
      return FilePath(boost::filesystem::current_path().string()) ;
#else
      return FilePath(boost::filesystem::current_path<path_t>().string()) ;
#endif
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      if (e.code() == boost::system::errc::no_such_file_or_directory)
      {
         // revert to the specified path if it exists, otherwise
         // take the user home path from the system
         FilePath safePath = revertToPath;
         if (!safePath.exists())
            safePath = core::system::userHomePath();

         Error error = safePath.makeCurrentPath();
         if (error)
            LOG_ERROR(error);

         return safePath;
      }
      else
      {
         throw;
      }
   }
}
   
Error FilePath::makeCurrent(const std::string& path)
{
   return FilePath(path).makeCurrentPath();
}

#define kHomePathAlias "~/"
#define kHomePathLeafAlias "~"

std::string FilePath::createAliasedPath(const FilePath& path,
                              const FilePath& userHomePath)
{
   // Special case for "~"
   if (path == userHomePath)
      return kHomePathLeafAlias;

   // if the path is contained within the home path then alias it
   std::string homeRelativePath = path.relativePath(userHomePath);
   if (!homeRelativePath.empty())
   {
      std::string aliasedPath = kHomePathAlias + homeRelativePath;
      return aliasedPath;
   }
   else  // no aliasing
   {
      return path.absolutePath();
   }
}

FilePath FilePath::resolveAliasedPath(const std::string& aliasedPath,
                            const FilePath& userHomePath)
{
   // Special case for  empty string or "~"
   if (aliasedPath.empty() || (aliasedPath.compare(kHomePathLeafAlias) == 0))
      return userHomePath;

   // if the path starts with the home alias then substitute the home path
   if (aliasedPath.find(kHomePathAlias) == 0)
   {
      std::string resolvedPath = userHomePath.absolutePath() +
      aliasedPath.substr(1);
      return FilePath(resolvedPath);
   }
   else  // no aliasing, this is either an absolute path or path
         // relative to the current directory
   {
      return FilePath::safeCurrentPath(userHomePath).complete(aliasedPath);
   }
}
 
FilePath::FilePath()
   : pImpl_(new Impl())
{
}
   
FilePath::FilePath(const std::string& absolutePath)
   : pImpl_(new Impl(fromString(std::string(absolutePath.c_str())))) // thwart ref-count
{
}

FilePath::~FilePath()
{
}


bool FilePath::empty() const
{
   return pImpl_->path.empty() ;
}

bool FilePath::exists() const
{
    try 
    {
       return !empty() && boost::filesystem::exists(pImpl_->path) ;
    }
    catch(const boost::filesystem::filesystem_error& e) 
    {
       logError(pImpl_->path, e, ERROR_LOCATION) ;
       return false ;
    }
}

uintmax_t FilePath::size() const
{
   try 
   {
      return boost::filesystem::file_size(pImpl_->path) ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      logError(pImpl_->path, e, ERROR_LOCATION) ;
      return 0;
   }
}

std::string FilePath::filename() const
{
   return BOOST_FS_STRING(pImpl_->path.filename()) ;
}

std::string FilePath::stem() const 
{
   return BOOST_FS_STRING(pImpl_->path.stem());
}

std::string FilePath::extension() const
{
   return BOOST_FS_STRING(pImpl_->path.extension()) ;
}
   
std::string FilePath::extensionLowerCase() const
{
   return string_utils::toLower(extension());
}
   
namespace {

struct MimeType
{
   const char* extension;
   const char* contentType;
} ;

MimeType s_mimeTypes[] =
{
   // most common web types
   { "htm",   "text/html" },
   { "html",  "text/html" },
   { "css",   "text/css" },
   { "gif",   "image/gif" },
   { "jpg",   "image/jpeg" },
   { "png",   "image/png" },
   { "js",    "application/x-javascript" },
   { "pdf",   "application/pdf" },
   { "svg",   "image/svg+xml" },
   { "swf",   "application/x-shockwave-flash" },
   
   // other types we are likely to serve
   { "xml",   "text/xml" },
   { "csv",   "text/csv" },
   { "ico",   "image/x-icon" },
   { "zip",   "application/zip" },
    
   // yet more types...
   
   { "shtml", "text/html" },
   { "tsv",   "text/tab-separated-values" },
   { "tab",   "text/tab-separated-values" },
   { "txt",   "text/plain" },
   { "mml",   "text/mathml" },
  
   { "tif",   "image/tiff" },
   { "tiff",  "image/tiff" },
      
   { "atom",  "application/atom+xml" },
   { "rss",   "application/rss+xml" },
   
   { "doc",   "application/msword" },
   { "docx",  "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
   { "odt",   "application/vnd.oasis.opendocument.text" },
   { "rtf",   "application/rtf" },
   { "xls",   "application/vnd.ms-excel" },
   { "xlsx",  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
   { "ods",   "application/x-vnd.oasis.opendocument.spreadsheet" },
   { "ppt",   "application/vnd.ms-powerpoint" },
   { "pps",   "application/vnd.ms-powerpoint" },
   { "pptx",  "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
 
   { "sit",   "application/x-stuffit" },
   { "sxw",   "application/vnd.sun.xml.writer" },
   
   { "iso",   "application/octet-stream" },
   { "dmg",   "application/octet-stream" },
   { "exe",   "application/octet-stream" },
   { "dll",   "application/octet-stream" },
   { "deb",   "application/octet-stream" },
   { "xpi",   "application/x-xpinstall" },
   
   { "mp3",   "audio/mpeg" },
   
   { "mpg",   "video/mpeg" },
   { "mpeg",  "video/mpeg" },
   { "flv",   "video/x-flv" },
  
   { NULL, NULL } 
};
   
}
   
std::string FilePath::mimeContentType(const std::string& defaultType) const
{
   std::string ext = extensionLowerCase();
   if (!ext.empty())
   {
      ext = ext.substr(1); // remove leading .
      for (MimeType* mimeType = s_mimeTypes; mimeType->extension; ++mimeType)
      {
         if (mimeType->extension == ext)
            return mimeType->contentType;
      }
      
      // none found
      return defaultType;
   }
   else
   {
      // no extension
      return defaultType;
   }
}
   
std::time_t FilePath::lastWriteTime() const
{
   try 
   {
     return boost::filesystem::last_write_time(pImpl_->path) ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      logError(pImpl_->path, e, ERROR_LOCATION) ;
      return 0;
   }
}

// NOTE: this does not properly handle .. and . path elements
std::string FilePath::relativePath(const FilePath& parentPath) const
{
   // get iterators to this path and parent path
   path_t::iterator thisBegin = pImpl_->path.begin() ;
   path_t::iterator thisEnd = pImpl_->path.end() ;
   path_t::iterator parentBegin = parentPath.pImpl_->path.begin();
   path_t::iterator parentEnd = parentPath.pImpl_->path.end() ;
   
   // if the child is fully prefixed by the parent
   path_t::iterator it = std::search(thisBegin, thisEnd, parentBegin, parentEnd);
   if ( it == thisBegin )
   {
      // search for mismatch location
      std::pair<path_t::iterator,path_t::iterator> mmPair =
                              std::mismatch(thisBegin, thisEnd, parentBegin);
      
      // build relative path from mismatch on
      path_t relativePath ;
      path_t::iterator mmit = mmPair.first ;
      while (mmit != thisEnd)
      {
         relativePath /= *mmit ;
         mmit++ ;
      }
      return BOOST_FS_PATH2STR(relativePath) ;
   }
   else
   {
      return std::string() ;
   }
}
   
bool FilePath::isWithin(const FilePath& scopePath) const
{
   if (*this == scopePath)
      return true ;
   
   std::string relativePath = this->relativePath(scopePath);
   return !relativePath.empty();
}


std::string FilePath::absolutePath() const
{
   if (empty())
      return std::string();
   else
      return BOOST_FS_PATH2STR(pImpl_->path) ;
}

Error FilePath::remove() const
{
   try
   {
      if (isDirectory())
         boost::filesystem::remove_all(pImpl_->path);
      else
         boost::filesystem::remove(pImpl_->path) ;
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      return error ;
   }
}
   
Error FilePath::removeIfExists() const
{
   if (exists())
      return remove();
   else
      return Success();
}
 
Error FilePath::move(const FilePath& targetPath) const
{
   try
   {
      boost::filesystem::rename(pImpl_->path, targetPath.pImpl_->path) ;
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      error.addProperty("target-path", targetPath.absolutePath()) ;
      return error ;
   }
}
   

Error FilePath::copy(const FilePath& targetPath) const
{
   try
   {
      boost::filesystem::copy_file(pImpl_->path, targetPath.pImpl_->path) ;
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      error.addProperty("target-path", targetPath.absolutePath()) ;
      return error ;
   }   
}


   
bool FilePath::isHidden() const 
{
   return system::isHiddenFile(*this) ;
}
   
   
bool FilePath::isDirectory() const 
{
   try 
   {
      return boost::filesystem::is_directory(pImpl_->path) ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      logError(pImpl_->path, e, ERROR_LOCATION) ;
      return false;
   }
}

   
Error FilePath::ensureDirectory() const
{
   if ( !exists() )
      return createDirectory(std::string()) ;
   else
      return Success() ;
}


Error FilePath::createDirectory(const std::string& name) const
{
   try
   {
      path_t targetDirectory ;
      if (name.empty())
         targetDirectory = pImpl_->path ;
      else
         targetDirectory = BOOST_FS_COMPLETE(name, pImpl_->path) ;
      boost::filesystem::create_directories(targetDirectory) ;
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      error.addProperty("target-dir", name) ;
      return error ;
   }
}
   
Error FilePath::resetDirectory() const
{
   Error error = removeIfExists();
   if (error)
      return error;
   
   return ensureDirectory();
}


FilePath FilePath::complete(const std::string& path) const
{
   // in-theory boost::filesystem::complete can throw but the conditions
   // are very obscure and are in any case a programming error. therefore,
   // we log silently if there is an error so that clients don't have to
   // deal with any error states (if there an error then a copy of 
   // this path is returned)
   try
   {
      // NOTE: The path gets round-tripped through toString/fromString, would
      //   be nice to have a direct constructor
      return FilePath(BOOST_FS_PATH2STR(BOOST_FS_COMPLETE(path, pImpl_->path)));
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      error.addProperty("path", path) ;
      LOG_ERROR(error) ;
      return *this ; 
   }
}
   
FilePath FilePath::parent() const
{
   try
   {
      // NOTE: The path gets round-tripped through toString/fromString, would
      //   be nice to have a direct constructor
      return FilePath(BOOST_FS_PATH2STR(pImpl_->path.parent_path()));
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      LOG_ERROR(error);
      return *this ; 
   }
}
   
// note: this differs from complete in the following ways:
//    - the passed path can be an empty string (returns self)
//    - the passed path must be relative
FilePath FilePath::childPath(const std::string& path) const 
{
   try
   {
      if (path.empty())
      {
         return *this ;
      }
      else
      {
         // confirm this is a relative path
         path_t relativePath(fromString(path));
         if (relativePath.has_root_path())
         {
            throw boost::filesystem::filesystem_error(
                           "absolute path not permitted",
                           boost::system::error_code(
                              boost::system::errc::no_such_file_or_directory,
                              boost::system::get_system_category()));
         }
         
         return complete(path);
      }
   }
   catch(const boost::filesystem::filesystem_error& e)
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      error.addProperty("path", path) ;
      LOG_ERROR(error);
      return *this ; 
   }
   
}

namespace {

Error notFoundError(const FilePath& filePath,
                        const ErrorLocation& location)
{
   Error error = pathNotFoundError(location);
   if (!filePath.empty())
      error.addProperty("path", filePath.absolutePath());
   return error;
}

}

Error FilePath::children(std::vector<FilePath>* pFilePaths) const
{
   if (!exists())
      return notFoundError(*this, ERROR_LOCATION);

   try 
   {
      dir_iterator end ;
      for (dir_iterator itr(pImpl_->path); itr != end; ++itr)
      {
         // NOTE: The path gets round-tripped through toString/fromString, would
         //   be nice to have a direct constructor
         std::string itemPath = BOOST_FS_PATH2STR(itr->path());
         pFilePaths->push_back(FilePath(itemPath)) ;
      }
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      return error ;
   }
}
   
 
Error FilePath::childrenRecursive(
                        RecursiveIterationFunction iterationFunction) const
{
   if (!exists())
      return notFoundError(*this, ERROR_LOCATION);

   try
   {
      recursive_dir_iterator end ;
      
      for (recursive_dir_iterator itr(pImpl_->path); itr != end; ++itr)
      {
         // NOTE: The path gets round-tripped through toString/fromString, would
         //   be nice to have a direct constructor
         iterationFunction(itr.level(),FilePath(BOOST_FS_PATH2STR(itr->path())));
      }
      
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;   
      return error ;
   }
}


Error FilePath::makeCurrentPath(bool autoCreate) const 
{
   if (autoCreate)
   {
      Error autoCreateError = ensureDirectory();
      if (autoCreateError)
         return autoCreateError ;
   }
   
   try 
   {
      boost::filesystem::current_path(pImpl_->path) ;
      return Success() ;
   }
   catch(const boost::filesystem::filesystem_error& e) 
   {
      Error error(e.code(), ERROR_LOCATION) ;
      addErrorProperties(pImpl_->path, &error) ;
      return error ;
   }
}

Error FilePath::open_r(boost::shared_ptr<std::istream>* pStream) const
{
   try
   {
      std::istream* pResult = NULL;
   #ifdef _WIN32
      using namespace boost::iostreams;
      HANDLE hFile = ::CreateFileW(pImpl_->path.wstring().c_str(),
                                   GENERIC_READ,
                                   FILE_SHARE_READ,
                                   NULL,
                                   OPEN_EXISTING,
                                   0,
                                   NULL);
      if (hFile == INVALID_HANDLE_VALUE)
      {
         Error error = systemError(::GetLastError(), ERROR_LOCATION);
         error.addProperty("path", absolutePath());
         return error;
      }
      boost::iostreams::file_descriptor_source fd;
      fd.open(hFile, boost::iostreams::close_handle);
      pResult = new boost::iostreams::stream<file_descriptor_source>(fd);
   #else
      pResult = new std::ifstream(absolutePath().c_str(),
                                  std::ios_base::in | std::ios_base::binary);
   #endif

      // In case we were able to make the stream but it failed to open
      if (!(*pResult))
      {
         delete pResult;

         Error error = systemError(boost::system::errc::no_such_file_or_directory, ERROR_LOCATION);
         error.addProperty("path", absolutePath());
         return error;
      }
      pStream->reset(pResult);
   }
   catch(const std::exception& e)
   {
      Error error = systemError(boost::system::errc::io_error,
                                ERROR_LOCATION);
      error.addProperty("what", e.what());
      error.addProperty("path", absolutePath());
      return error;
   }


   return Success();
}

Error FilePath::open_w(boost::shared_ptr<std::ostream>* pStream, bool truncate) const
{
   try
   {
      std::ostream* pResult = NULL;
   #ifdef _WIN32
      using namespace boost::iostreams;
      HANDLE hFile = ::CreateFileW(pImpl_->path.wstring().c_str(),
                                   GENERIC_WRITE,
                                   0, // exclusive access
                                   NULL,
                                   truncate ? CREATE_ALWAYS : OPEN_ALWAYS,
                                   0,
                                   NULL);
      if (hFile == INVALID_HANDLE_VALUE)
      {
         Error error = systemError(::GetLastError(), ERROR_LOCATION);
         error.addProperty("path", absolutePath());
         return error;
      }
      file_descriptor_sink fd;
      fd.open(hFile, close_handle);
      pResult = new boost::iostreams::stream<file_descriptor_sink>(fd);
   #else
      using std::ios_base;
      ios_base::openmode flags = ios_base::out | ios_base::binary;
      if (truncate)
         flags |= ios_base::trunc;
      else
         flags |= ios_base::app;
      pResult = new std::ofstream(absolutePath().c_str(), flags);
   #endif

      if (!(*pResult))
      {
         delete pResult;

         Error error = systemError(boost::system::errc::no_such_file_or_directory, ERROR_LOCATION);
         error.addProperty("path", absolutePath());
         return error;
      }

      pStream->reset(pResult);
   }
   catch(const std::exception& e)
   {
      Error error = systemError(boost::system::errc::io_error,
                                ERROR_LOCATION);
      error.addProperty("what", e.what());
      error.addProperty("path", absolutePath());
      return error;
   }

   return Success();
}

bool FilePath::operator== (const FilePath& filePath) const 
{
   return pImpl_->path == filePath.pImpl_->path ;
}

bool FilePath::operator!= (const FilePath& filePath) const
{
   return pImpl_->path != filePath.pImpl_->path ;
}
   
bool FilePath::operator < (const FilePath& other) const 
{
   return pImpl_->path < other.pImpl_->path ;
}

std::ostream& operator << (std::ostream& stream, const FilePath& fp)
{
   stream << fp.absolutePath();
   return stream ;
}

bool compareAbsolutePathNoCase(const FilePath& file1, const FilePath& file2)
{
   std::string file1Lower = string_utils::toLower(file1.absolutePath());
   std::string file2Lower = string_utils::toLower(file2.absolutePath());
   return file1Lower < file2Lower;
}

namespace { 
void logError(path_t path,
              const boost::filesystem::filesystem_error& e,
              const core::ErrorLocation& errorLocation)
{
   Error error(e.code(), errorLocation) ;
   addErrorProperties(path, &error) ;   
   core::log::logError(error, errorLocation) ;
}

void addErrorProperties(path_t path, Error* pError)
{
   pError->addProperty("path", BOOST_FS_PATH2STR(path)) ;
}
}

} // namespace core