filesystem.hh

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
 
#include "string.hh"
 
namespace Dune::Vtk
{
  // A minimalistic filesystem class
  class Path
      : public std::vector<std::string>
  {
    using Super = std::vector<std::string>;
    using iterator = Super::iterator;
    using const_iterator = Super::const_iterator;
 
  public:
#ifdef _WIN32
    static constexpr char preferredSeparator = '\\';
#else
    static constexpr char preferredSeparator = '/';
#endif
 
  public:
    Path() = default;
 
    // NOTE: implicit conversion is allowed here
    template <class String>
    Path(String const& p)
      : original(p)
    {
      split(p);
    }
 
    template <class InputIt>
    Path(InputIt it, InputIt end_it)
      : Super(it, end_it)
    {
      original = this->string();
    }
 
    template <class String>
    Path(std::initializer_list<String> const& list)
      : Path(list.begin(), list.end())
    {}
 
    Path& removeFilename()
    {
      this->pop_back();
      return *this;
    }
 
    Path parentPath() const
    {
      return empty() ? Path() : Path(begin(), --end());
    }
 
    Path filename() const
    {
      return empty() ? Path() : Path(back());
    }
 
    Path stem() const;
 
    Path extension() const;
 
    std::string string() const;
 
 
    static bool isAbsolute(std::string p);
 
    bool isAbsolute() const { return isAbsolute(original); }
 
    bool isRelative() const { return !isAbsolute(); }
 
    bool isFile() const;
 
    bool isDirectory() const;
 
    bool operator==(Path const& p)
    {
      return this->string() == p.string();
    }
 
    Path& operator/=(Path const& p);
 
    template <class CharT, class Traits>
    friend std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& out, Path const& p)
    {
      out << '"' << p.string() << '"';
      return out;
    }
 
  protected:
 
    // split the path string into names separated by a `/`, remove relative directories,
    // like `.` or `..`, if possible.
    void split(std::string p);
 
  private:
    std::string original = "";
  };
 
  bool exists(Path const&);
 
  bool createDirectories(Path const&);
 
  Path currentPath();
 
  Path relative(Path const& a, Path const& b);
 
  inline Path operator/ (Path lhs, Path const& rhs)
  {
    return lhs /= rhs;
  }
 
} // end namespace Dune::Vtk