JFilesystem.hh

Go to the documentation of this file.

#ifndef __JSYSTEM_JFILEJSYSTEM__
#define __JSYSTEM_JFILEJSYSTEM__
 
#include <string>
#include <vector>
#include <fstream>
#include <filesystem>
#include <set>
#include <stdexcept>
#include <dirent.h>
 
 
namespace JSYSTEM {}
namespace JPP { using namespace JSYSTEM; }
 
namespace JSYSTEM {
 
  /**
   * Resolve symbolic links.
   *
   * \param  file_name             file name
   * \return                       file name
   */
  inline std::filesystem::path resolveSymlink(const std::filesystem::path& file_name)
  {
    using namespace std::filesystem;
 
    path ps(file_name);
 
    if (is_symlink(ps)) {
      try {
        ps = canonical(ps);
      }
      catch(const std::exception&) {
        std::set<path> seen;
 
        while (true) {
          const path target = read_symlink(ps);
          const path next = ps.parent_path() / target;
 
          if (!is_symlink(next)) {
            ps = target;
            break;
          }
 
          if (!seen.insert(next).second) {
            throw std::runtime_error("Cyclic symbolic links while resolving " + file_name.string());
          }
 
          ps = next;
        }
      }
    }
 
    return ps;
  }
 
 
  /**
   * Auxiliary data structure to list files in directory.
   */
  struct ls :
    public std::vector<std::string>
  {
    /**
     * Constructor.
     *
     * \param  dir                   directory
     */
    ls(const std::string& dir)
    {
      DIR* top = opendir(dir.c_str());
 
      if (top != NULL) {
 
        for (dirent* i; (i = readdir(top)) != NULL; ) {
          this->push_back(i->d_name);
        }
 
        closedir(top);
      }
    }
  };
 
 
  /**
   * Rename file across file systems.
   *
   * \param  inputFile     input file
   * \param  outputFile    input file
   * \return               zero upon success; else non-zero
   */
  inline int rename(const std::string& inputFile, 
                    const std::string& outputFile)
  {
    using namespace std;
 
    ifstream in (inputFile .c_str(), ios::binary);
    ofstream out(outputFile.c_str(), ios::binary);
 
    out << in.rdbuf();
 
    if (out) 
      return remove(inputFile.c_str());
    else
      return -1;
  }
}
 
#endif