utility routines to convert to/from collections of paths

mdaus · Dec 6, 2023 · 2a88bf6 · 2a88bf6
1 parent a377744
commit 2a88bf6
Show file tree

Hide file tree

Showing 4 changed files with 35 additions and 35 deletions.
diff --git a/modules/c++/sys/include/sys/Path.h b/modules/c++/sys/include/sys/Path.h
@@ -27,13 +27,15 @@
 #include <string>
 #include <deque>
 #include <utility>
+#include <vector>
 
 #include "config/Exports.h"
-
 #include <import/str.h>
+#include "coda_oss/span.h"
 
 #include "sys/OS.h"
 #include "sys/filesystem.h"
+#include "sys/Span.h"
 
 
 /*!
@@ -295,6 +297,16 @@ class CODA_OSS_API Path
 
 std::ostream& operator<<(std::ostream& os, const sys::Path& path);
 std::istream& operator>>(std::istream& os, sys::Path& path);
+
+// Convert between collections of paths as strings and sys::filesystem::path
+CODA_OSS_API std::vector<std::string> convertPaths(coda_oss::span<const filesystem::path>);
+CODA_OSS_API std::vector<filesystem::path> convertPaths(coda_oss::span<const std::string>);
+template<typename T>
+inline auto convertPaths(const std::vector<T>& paths)
+{
+    return convertPaths(make_span(paths));
+}
+
 }
 
 #endif // CODA_OSS_sys_Path_h_INCLUDED_
diff --git a/modules/c++/sys/source/AbstractOS.cpp b/modules/c++/sys/source/AbstractOS.cpp
@@ -86,29 +86,14 @@ AbstractOS::search(const std::vector<std::string>& searchPaths,
     return elementsFound;
 }
 
-inline auto convert(const std::vector<fs::path>& paths)
-{
-    std::vector<std::string> retval;
-    std::transform(paths.begin(), paths.end(), std::back_inserter(retval),
-                   [](const fs::path& p) { return p.string(); });
-    return retval;
-}
-inline auto convert(const std::vector<std::string>& paths)
-{
-    std::vector<fs::path> retval;
-    std::transform(paths.begin(), paths.end(), std::back_inserter(retval),
-                   [](const auto& p) { return p; });
-    return retval;
-}
-
 std::vector<coda_oss::filesystem::path> AbstractOS::search(
         const std::vector<coda_oss::filesystem::path>& searchPaths,
         const std::string& fragment,
         const std::string& extension,
         bool recursive) const
 {
-    const auto results = search(convert(searchPaths), fragment, extension, recursive);
-    return convert(results);
+    const auto results = search(convertPaths(searchPaths), fragment, extension, recursive);
+    return convertPaths(results);
 }
 
 void AbstractOS::remove(const std::string& path) const

diff --git a/modules/c++/sys/source/Path.cpp b/modules/c++/sys/source/Path.cpp
@@ -22,6 +22,7 @@
 #include "sys/Path.h"
 
 #include <algorithm>
+#include <iterator>
 
 #include <sys/filesystem.h>
 namespace fs = coda_oss::filesystem;
@@ -849,4 +850,20 @@ std::string Path::expandEnvironmentVariables(const std::string& path, fs::file_t
     return expandEnvironmentVariables_(path, unused_checkIfExists, &type);
 }
 
+template<typename TReturn, typename TSpan, typename TFunc>
+inline auto convertPaths_(coda_oss::span<const TSpan> paths, TFunc fun)
+{
+    std::vector<TReturn> retval;
+    std::transform(paths.begin(), paths.end(), std::back_inserter(retval), fun);
+    return retval;
+}
+std::vector<std::string> convertPaths(coda_oss::span<const fs::path> paths)
+{
+    return convertPaths_<std::string>(paths, [](const auto& p) { return p.string(); });
 }
+std::vector<fs::path> convertPaths(coda_oss::span<const std::string> paths)
+{
+    return convertPaths_<fs::path>(paths, [](const auto& p) { return p; });
+}
+
+}
diff --git a/modules/c++/xml.lite/source/ValidatorXerces.cpp b/modules/c++/xml.lite/source/ValidatorXerces.cpp
@@ -37,6 +37,7 @@ CODA_OSS_disable_warning(-Wshadow)
 CODA_OSS_disable_warning_pop
 
 #include <sys/OS.h>
+#include <sys/Path.h>
 #include <io/StringStream.h>
 #include <mem/ScopedArray.h>
 
@@ -89,26 +90,11 @@ bool ValidationErrorHandler::handleError(
     return true;
 }
 
-inline std::vector<std::string> convert(const std::vector<fs::path>& schemaPaths)
-{
-    std::vector<std::string> retval;
-    std::transform(schemaPaths.begin(), schemaPaths.end(), std::back_inserter(retval),
-                   [](const fs::path& p) { return p.string(); });
-    return retval;
-}
-inline auto convert(const std::vector<std::string>& paths)
-{
-    std::vector<fs::path> retval;
-    std::transform(paths.begin(), paths.end(), std::back_inserter(retval),
-                   [](const auto& p) { return p; });
-    return retval;
-}
-
 ValidatorXerces::ValidatorXerces(
         const std::vector<fs::path>& schemaPaths,
         logging::Logger* log,
         bool recursive) :
-    ValidatorXerces(convert(schemaPaths), log, recursive)
+    ValidatorXerces(sys::convertPaths(schemaPaths), log, recursive)
 {
 }
 ValidatorXerces::ValidatorXerces(
@@ -169,7 +155,7 @@ ValidatorXerces::ValidatorXerces(
 
     // load our schemas --
     // search each directory for schemas
-    const auto schemas = loadSchemas(convert(schemaPaths), recursive);
+    const auto schemas = loadSchemas(sys::convertPaths(schemaPaths), recursive);
 
     //  add the schema to the validator
     //  add the schema to the validator