change const char paths to std::filesystem::path

io.cpp

@@ -36,7 +36,7 @@ using namespace util;
 
 //----------------------------------------------------------------------------
 std::vector<char>
-util::slurp (const char *path)
+util::slurp (const std::experimental::filesystem::path &path)
 {
     posix::fd out (path, O_RDONLY | O_BINARY);
 
@@ -70,14 +70,6 @@ util::slurp (const char *path)
 }
 
 
-//-----------------------------------------------------------------------------
-std::vector<char>
-util::slurp (const std::string &path)
-{
-    return slurp (path.c_str ());
-}
-
-
 //-----------------------------------------------------------------------------
 std::vector<char>
 util::slurp (FILE *stream)

io.hpp

@@ -38,8 +38,7 @@
 namespace util {
     //-------------------------------------------------------------------------
     /// Reads an entire file into memory.
-    std::vector<char> slurp (const char *path);
+    std::vector<char> slurp (const std::experimental::filesystem::path&);
-    std::vector<char> slurp (const std::string &path);
     std::vector<char> slurp (FILE *);
 
 

io_posix.cpp

@@ -26,8 +26,9 @@
 
 using util::detail::posix::mapped_file;
 
+
 //////////////////////////////////////////////////////////////////////////////
-mapped_file::mapped_file (const char *path, int fflags, int mflags):
+mapped_file::mapped_file (const std::experimental::filesystem::path &path, int fflags, int mflags):
     mapped_file (util::posix::fd (path, fflags), mflags)
 { ; }
 

io_posix.hpp

@@ -22,6 +22,7 @@
 #include "view.hpp"
 
 #include <type_traits>
+#include <experimental/filesystem>
 
 #include <sys/mman.h>
 #include <fcntl.h>
@@ -30,7 +31,7 @@ namespace util {
     namespace detail { namespace posix {
         class mapped_file {
         public:
-            mapped_file (const char *path, int fflags = O_RDONLY | O_BINARY, int mflags = PROT_READ);
+            mapped_file (const std::experimental::filesystem::path&, int fflags = O_RDONLY | O_BINARY, int mflags = PROT_READ);
             mapped_file (const util::posix::fd&,  int mflags = PROT_READ);
 
             mapped_file (const mapped_file&) = delete;

library_posix.cpp

@@ -24,14 +24,8 @@ using util::detail::library_posix;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-library_posix::library_posix (const std::string &path):
+library_posix::library_posix (const std::experimental::filesystem::path &path):
-    library_posix (path.c_str ())
+    m_handle (dlopen (path.c_str (), RTLD_NOW))
-{ ; }
-
-
-//-----------------------------------------------------------------------------
-library_posix::library_posix (const char *path):
-    m_handle (dlopen (path, RTLD_NOW))
 {
     if (!m_handle)
         throw std::runtime_error (dlerror ());

library_posix.hpp

@@ -17,14 +17,13 @@
 #ifndef __UTIL_LIBRARY_POSIX_HPP
 #define __UTIL_LIBRARY_POSIX_HPP
 
-#include <string>
+#include <experimental/filesystem>
 
 namespace util {
     namespace detail {
         class library_posix {
         public:
-            explicit library_posix (const char *path);
+            explicit library_posix (const std::experimental::filesystem::path&);
-            explicit library_posix (const std::string &path);
             library_posix (library_posix&&);
             ~library_posix ();
 

library_win32.cpp

@@ -22,20 +22,14 @@ using util::detail::win32::library;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-library::library (const char *path):
+library::library (const std::experimental::filesystem::path &path)
-    m_handle (LoadLibraryA (path))
+    m_handle (LoadLibraryA (path.c_str ()))
 {
     if (!m_handle)
         win32_error::throw_code ();
 }
 
 
-//-----------------------------------------------------------------------------
-library::library (const std::string &path):
-    library (path.c_str ())
-{ ; }
-
-
 //-----------------------------------------------------------------------------
 library::~library ()
 {

library_win32.hpp

@@ -17,15 +17,15 @@
 #ifndef __UTIL_LIBRARY_WIN32_HPP
 #define __UTIL_LIBRARY_WIN32_HPP
 
-#include <string>
 #include <windows.h>
 
+#include <experimental/filesystem>
+
 namespace util {
     namespace detail { namespace win32 {
         class library {
         public:
-            library (const char *path);
+            library (const std::experimenal::filesystem::path&);
-            library (const std::string &path);
             ~library ();
 
             void* symbol (const char *name);

posix/dir.cpp

@@ -22,31 +22,8 @@ using util::posix::dir;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-//struct entry {
+dir::dir (const std::experimental::filesystem::path &p):
-//public:
+    m_handle (::opendir (p.c_str ()))
-//    entry (dirent *_handle, DIR *_parent): m_handle (_handle), m_parent (_parent) { ; }
-//
-//    const char* name (void) const { return m_handle->d_name; }
-//
-//    entry& operator++ (void) {
-//        dirent *next = readdir (m_parent);
-//        assert (!next || next != m_handle);
-//        m_handle = next;
-//        return *this;
-//    }
-//
-//    entry& operator* (void) { return *this; }
-//    const entry& operator* (void) const;
-//    bool operator!= (entry rhs) const { return m_handle != rhs.m_handle || m_parent != rhs.m_parent; }
-//
-//    struct dirent *m_handle;
-//    DIR *m_parent;
-//};
-
-
-///////////////////////////////////////////////////////////////////////////////
-dir::dir (const char *path):
-    m_handle (opendir (path))
 {
     if (!m_handle)
         errno_error::throw_code ();

posix/dir.hpp

@@ -21,43 +21,23 @@
 #include <dirent.h>
 
 #include <functional>
+#include <experimental/filesystem>
 
 namespace util { namespace posix {
-    //struct entry {
-    //public:
-    //    entry (dirent *_handle, DIR *_parent): m_handle (_handle), m_parent (_parent) { ; }
-
-    //    const char* name (void) const { return m_handle->d_name; }
-
-    //    entry& operator++ (void) {
-    //        dirent *next = readdir (m_parent);
-    //        assert (!next || next != m_handle);
-    //        m_handle = next;
-    //        return *this;
-    //    }
-
-    //    entry& operator* (void) { return *this; }
-    //    const entry& operator* (void) const;
-    //    bool operator!= (entry rhs) const { return m_handle != rhs.m_handle || m_parent != rhs.m_parent; }
-
-    //    struct dirent *m_handle;
-    //    DIR *m_parent;
-    //};
-
     struct dir {
     public:
-        explicit dir (const char *path);
+        explicit dir (const std::experimental::filesystem::path&);
         ~dir ();
 
         operator DIR* (void);
 
         template <typename ...Args>
         void
-        scan (std::function<void(const char*, Args&...)>, Args&...);
+        scan (std::function<void(const std::experimental::filesystem::path&, Args&...)>, Args&...);
 
         template <typename ...Args>
         void
-        scan (void (*) (const char*, Args&...), Args&...);
+        scan (void (*) (const std::experimental::filesystem::path&, Args&...), Args&...);
 
         //entry begin (void) { rewind (); return { readdir (m_handle), m_handle }; }
         //entry end (void) { return { nullptr, m_handle }; }

posix/dir.ipp

@@ -22,7 +22,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 template <typename ...Args>
 void
-util::posix::dir::scan(std::function<void(const char*, Args&...)> cb, Args &...args)
+util::posix::dir::scan(std::function<void(const std::experimental::filesystem::path&, Args&...)> cb, Args &...args)
 {
     rewind ();
 
@@ -36,7 +36,7 @@ util::posix::dir::scan(std::function<void(const char*, Args&...)> cb, Args &...a
 //-----------------------------------------------------------------------------
 template <typename ...Args>
 void
-util::posix::dir::scan (void (*cb) (const char*, Args&...), Args &...args)
+util::posix::dir::scan (void (*cb) (const std::experimental::filesystem::path&, Args&...), Args &...args)
 {
     rewind ();
 

posix/fd.cpp

@@ -26,33 +26,18 @@ using util::posix::fd;
 
 
 ///////////////////////////////////////////////////////////////////////////////
-fd::fd (const char *path, int flags):
+fd::fd (const std::experimental::filesystem::path &path, int flags):
-    m_fd (::open (path, flags, 0666))
+    fd (path, flags, 0666)
-{
-    if (m_fd < 0)
-        errno_error::throw_code ();
-}
-
-
-//-----------------------------------------------------------------------------
-fd::fd (const char *path, int flags, mode_t mode):
-    m_fd (::open (path, flags, mode))
-{
-    if (m_fd < 0)
-        errno_error::throw_code ();
-}
-
-
-//-----------------------------------------------------------------------------
-fd::fd (const std::string &path, int flags):
-    fd (path.c_str (), flags)
 { ; }
 
 
 //-----------------------------------------------------------------------------
-fd::fd (const std::string &path, int flags, mode_t mode):
+fd::fd (const std::experimental::filesystem::path &path, int flags, mode_t mode):
-    fd (path.c_str (), flags, mode)
+    m_fd (::open (path.c_str (), flags, mode))
-{ ; }
+{
+    if (m_fd < 0)
+        errno_error::throw_code ();
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////

posix/fd.hpp

@@ -22,16 +22,16 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 
+#include <experimental/filesystem>
+
 namespace util::posix {
     ///------------------------------------------------------------------------
     /// A simple RAII wrapper for file descriptors
     class fd {
     public:
         ///////////////////////////////////////////////////////////////////////
-        fd (const std::string &path, int flags);
+        fd (const std::experimental::filesystem::path &path, int flags);
-        fd (const std::string &path, int flags, mode_t);
+        fd (const std::experimental::filesystem::path &path, int flags, mode_t);
-        fd (const char *path, int flags);
-        fd (const char *path, int flags, mode_t);
 
         fd (fd &&);