Implement directory iteration support

3 files changed, 313 insertions, 4 deletions

diff --git a/butl/filesystem b/butl/filesystem
index 18ba48e..4d0b7ef 100644
--- a/butl/filesystem
+++ b/butl/filesystem
@@ -7,6 +7,14 @@
 
 #include <sys/types.h> // mode_t
 
+#ifndef _WIN32
+#  include <dirent.h> // DIR, struct dirent, *dir()
+#endif
+
+#include <cstddef>  // ptrdiff_t
+#include <utility>  // move()
+#include <iterator>
+
 #include <butl/path>
 #include <butl/timestamp>
 
@@ -65,6 +73,117 @@ namespace butl
 
   rmfile_status
   try_rmfile (const path&);
+
+  // Directory entry iteration.
+  //
+  enum class entry_type
+  {
+    unknown,
+    regular,
+    directory,
+    symlink,
+    other
+  };
+
+  class dir_entry
+  {
+  public:
+    typedef butl::path path_type;
+
+    entry_type
+    type () const;
+
+    // Symlink target type in case of the symlink, type() otherwise.
+    //
+    entry_type
+    ltype () const;
+
+    // Entry path (excluding the base). To get the full path, do
+    // base () / path ().
+    //
+    const path_type&
+    path () const {return p_;}
+
+    const dir_path&
+    base () const {return b_;}
+
+    dir_entry () = default;
+    dir_entry (entry_type t, path_type p, dir_path b)
+        : t_ (t), p_ (std::move (p)), b_ (std::move (b)) {}
+
+  private:
+    entry_type
+    type (bool link) const;
+
+  private:
+    friend class dir_iterator;
+
+    mutable entry_type t_ = entry_type::unknown;  // Lazy evaluation.
+    mutable entry_type lt_ = entry_type::unknown; // Lazy evaluation.
+    path_type p_;
+    dir_path b_;
+  };
+
+  class dir_iterator
+  {
+  public:
+    typedef dir_entry value_type;
+    typedef const dir_entry* pointer;
+    typedef const dir_entry& reference;
+    typedef std::ptrdiff_t difference_type;
+    typedef std::input_iterator_tag iterator_category;
+
+    ~dir_iterator ();
+    dir_iterator () = default;
+
+    explicit
+    dir_iterator (const dir_path&);
+
+    dir_iterator (const dir_iterator&) = delete;
+    dir_iterator& operator= (const dir_iterator&) = delete;
+
+    dir_iterator (dir_iterator&& x);
+    dir_iterator& operator= (dir_iterator&&);
+
+    dir_iterator& operator++ () {next (); return *this;}
+
+    reference operator* () const {return e_;}
+    pointer operator-> () const {return &e_;}
+
+    friend bool operator== (const dir_iterator&, const dir_iterator&);
+    friend bool operator!= (const dir_iterator&, const dir_iterator&);
+
+  private:
+    void
+    next ();
+
+  private:
+    dir_entry e_;
+
+#ifndef _WIN32
+    DIR* h_ {nullptr};
+#else
+    // Check move implementation.
+    //
+#  error Win32 implementation lacking
+#endif
+  };
+
+  // Range-based for loop support.
+  //
+  // for (const auto& de: dir_iterator (dir_path ("/tmp"))) ...
+  //
+  // Note that the "range" (which is the "begin" iterator), is no
+  // longer usable. In other words, don't do this:
+  //
+  // dir_iterator i (...);
+  // for (...: i) ...
+  // ++i; // Invalid.
+  //
+  inline dir_iterator begin (dir_iterator& i) {return std::move (i);}
+  inline dir_iterator end (const dir_iterator&) {return dir_iterator ();}
 }
 
+#include <butl/filesystem.ixx>
+
 #endif // BUTL_FILESYSTEM
diff --git a/butl/filesystem.cxx b/butl/filesystem.cxx
index 7c8893e..4cf60b2 100644
--- a/butl/filesystem.cxx
+++ b/butl/filesystem.cxx
@@ -8,6 +8,7 @@
 #include <sys/types.h> // stat
 #include <sys/stat.h>  // stat, lstat(), S_IS*, mkdir()
 
+#include <memory>       // unique_ptr
 #include <system_error>
 
 using namespace std;
@@ -17,25 +18,25 @@ namespace butl
   // Figuring out whether we have the nanoseconds in some form.
   //
   template <typename S>
-  constexpr auto nsec (const S* s) -> decltype(s->st_mtim.tv_nsec)
+  inline constexpr auto nsec (const S* s) -> decltype(s->st_mtim.tv_nsec)
   {
     return s->st_mtim.tv_nsec; // POSIX (GNU/Linux, Solaris).
   }
 
   template <typename S>
-  constexpr auto nsec (const S* s) -> decltype(s->st_mtimespec.tv_nsec)
+  inline constexpr auto nsec (const S* s) -> decltype(s->st_mtimespec.tv_nsec)
   {
     return s->st_mtimespec.tv_nsec; // MacOS X.
   }
 
   template <typename S>
-  constexpr auto nsec (const S* s) -> decltype(s->st_mtime_n)
+  inline constexpr auto nsec (const S* s) -> decltype(s->st_mtime_n)
   {
     return s->st_mtime_n; // AIX 5.2 and later.
   }
 
   template <typename S>
-  constexpr int nsec (...) {return 0;}
+  inline constexpr int nsec (...) {return 0;}
 
   timestamp
   file_mtime (const path& p)
@@ -140,4 +141,128 @@ namespace butl
 
     return r;
   }
+
+#ifndef _WIN32
+
+  // dir_entry
+  //
+  entry_type dir_entry::
+  type (bool link) const
+  {
+    path_type p (b_ / p_);
+    struct stat s;
+    if ((link
+         ? ::stat (p.string ().c_str (), &s)
+         : ::lstat (p.string ().c_str (), &s)) != 0)
+    {
+      throw system_error (errno, system_category ());
+    }
+
+    entry_type r;
+
+    if (S_ISREG (s.st_mode))
+      r = entry_type::regular;
+    else if (S_ISDIR (s.st_mode))
+      r = entry_type::directory;
+    else if (S_ISLNK (s.st_mode))
+      r = entry_type::symlink;
+    else
+      r = entry_type::other;
+
+    return r;
+  }
+
+  // dir_iterator
+  //
+  struct dir_deleter
+  {
+    void operator() (DIR* p) const {if (p != nullptr) ::closedir (p);}
+  };
+
+  dir_iterator::
+  dir_iterator (const dir_path& d)
+  {
+    unique_ptr<DIR, dir_deleter> h (::opendir (d.string ().c_str ()));
+    h_ = h.get ();
+
+    if (h_ == nullptr)
+      throw system_error (errno, system_category ());
+
+    next ();
+
+    if (h_ != nullptr)
+      e_.b_ = d;
+
+    h.release ();
+  }
+
+  template <typename D>
+  inline /*constexpr*/ entry_type d_type (const D* d, decltype(d->d_type)*)
+  {
+    switch (d->d_type)
+    {
+#ifdef DT_DIR
+    case DT_DIR: return entry_type::directory;
+#endif
+#ifdef DT_REG
+    case DT_REG: return entry_type::regular;
+#endif
+#ifdef DT_LNK
+    case DT_LNK: return entry_type::symlink;
+#endif
+#ifdef DT_BLK
+    case DT_BLK:
+#endif
+#ifdef DT_CHR
+    case DT_CHR:
+#endif
+#ifdef DT_FIFO
+    case DT_FIFO:
+#endif
+#ifdef DT_SOCK
+    case DT_SOCK:
+#endif
+      return entry_type::other;
+
+    default: return entry_type::unknown;
+    }
+  }
+
+  template <typename D>
+  inline constexpr entry_type d_type (...) {return entry_type::unknown;}
+
+  void dir_iterator::
+  next ()
+  {
+    for (;;)
+    {
+      errno = 0;
+      if (struct dirent* de = ::readdir (h_))
+      {
+        const char* n (de->d_name);
+
+        // Skip '.' and '..'.
+        //
+        if (n[0] == '.' && (n[1] == '\0' || (n[1] == '.' && n[2] == '\0')))
+          continue;
+
+        e_.p_ = path (n);
+        e_.t_ = d_type<struct dirent> (de, nullptr);
+        e_.lt_ = entry_type::unknown;
+      }
+      else if (errno == 0)
+      {
+        // End of stream.
+        //
+        ::closedir (h_);
+        h_ = nullptr;
+      }
+      else
+        throw system_error (errno, system_category ());
+
+      break;
+    }
+  }
+#else
+#endif
 }
diff --git a/butl/filesystem.ixx b/butl/filesystem.ixx
new file mode 100644
index 0000000..7aa3622
--- /dev/null
+++ b/butl/filesystem.ixx
@@ -0,0 +1,65 @@
+// file      : butl/filesystem.ixx -*- C++ -*-
+// copyright : Copyright (c) 2014-2015 Code Synthesis Ltd
+// license   : MIT; see accompanying LICENSE file
+
+namespace butl
+{
+  // dir_entry
+  //
+  inline entry_type dir_entry::
+  type () const
+  {
+    return t_ != entry_type::unknown ? t_ : (t_ = type (false));
+  }
+
+  inline entry_type dir_entry::
+  ltype () const
+  {
+    entry_type t (type ());
+    return t != entry_type::symlink
+      ? t
+      : lt_ != entry_type::unknown ? lt_ : (lt_ = type (true));
+  }
+
+  // dir_iterator
+  //
+  inline dir_iterator::
+  dir_iterator (dir_iterator&& x): e_ (std::move (x.e_)), h_ (x.h_)
+  {
+    x.h_ = nullptr;
+  }
+
+  inline dir_iterator& dir_iterator::
+  operator= (dir_iterator&& x)
+  {
+    if (this != &x)
+    {
+      e_ = std::move (x.e_);
+      h_ = x.h_;
+      x.h_ = nullptr;
+    }
+    return *this;
+  }
+
+  inline bool
+  operator== (const dir_iterator& x, const dir_iterator& y)
+  {
+    return x.h_ == y.h_;
+  }
+
+  inline bool
+  operator!= (const dir_iterator& x, const dir_iterator& y)
+  {
+    return !(x == y);
+  }
+
+#ifndef _WIN32
+  inline dir_iterator::
+  ~dir_iterator ()
+  {
+    if (h_ != nullptr)
+      ::closedir (h_); // Ignore any errors.
+  }
+#else
+#endif
+}