Elements  5.10
A C++ base framework for the Euclid Software.
Path.icpp
Go to the documentation of this file.
1 /**
2  * @file ElementsKernel/_impl/Path.icpp
3  * @brief implementation of the templates declared in ElementsKernel/Path.h
4  * @date May 17, 2016
5  * @author Hubert Degaudenzi
6  *
7  * @copyright 2012-2020 Euclid Science Ground Segment
8  *
9  * This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General
10  * Public License as published by the Free Software Foundation; either version 3.0 of the License, or (at your option)
11  * any later version.
12  *
13  * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
14  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
15  * details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to
18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef ELEMENTSKERNEL__IMPL_PATH_ICPP_
22 #define ELEMENTSKERNEL__IMPL_PATH_ICPP_
23 
24 #include <string> // for string
25 #include <vector> // for vector
26 #include <unordered_set> // for unordered_set
27 #include <algorithm> // for find_if, transform, for_each
28 
29 #include <boost/filesystem.hpp> // for boost::filesystem
30 #include <boost/algorithm/string/join.hpp> // for join
31 
32 
33 namespace Elements {
34 namespace Path {
35 
36 template <typename T, typename U>
37 boost::filesystem::path getPathFromLocations(const T& file_name, const std::vector<U>& locations) {
38 
39  using boost::filesystem::path;
40 
41  path found_path {};
42  path file_path {file_name};
43 
44  auto found_pos = std::find_if(locations.cbegin(), locations.cend(),
45  [file_path](const U& l) {
46  return boost::filesystem::exists(path {l} / file_path);
47  });
48 
49  if (found_pos != locations.cend()) {
50  found_path = path {*found_pos} / file_path;
51  }
52 
53  return found_path;
54 
55 }
56 
57 template <typename T, typename U>
58 std::vector<boost::filesystem::path> getAllPathFromLocations(const T& file_name, const std::vector<U>& locations) {
59 
60  using boost::filesystem::path;
61 
62  std::vector<path> file_list(locations.size());
63  path file_path {file_name};
64 
65  std::transform(locations.cbegin(), locations.cend(),
66  file_list.begin(),
67  [file_path](const U& l){
68  return path {l} / file_path;
69  });
70 
71  auto found_pos = std::remove_if(file_list.begin(), file_list.end(),
72  [](const path& p){
73  return not boost::filesystem::exists(p);
74  });
75 
76  file_list.erase(found_pos, file_list.end());
77 
78  return removeDuplicates(file_list);
79 
80 }
81 
82 template <typename T>
83 boost::filesystem::path getPathFromEnvVariable(const T& file_name, const std::string& path_variable) {
84 
85  using std::vector;
86  using boost::filesystem::path;
87 
88  vector<path> location_list = getLocationsFromEnv(path_variable);
89 
90  return getPathFromLocations(file_name, location_list);
91 
92 }
93 
94 template <typename T>
95 std::string joinPath(const std::vector<T>& path_list) {
96 
97  using std::vector;
98  using std::string;
99 
100  vector<string> elems(path_list.size());
101 
102  std::transform(path_list.cbegin(), path_list.cend(),
103  elems.begin(),
104  [](const T& s){
105  return boost::filesystem::path{s}.string();
106  });
107 
108  std::string result = boost::algorithm::join(elems, PATH_SEP);
109 
110  return result;
111 }
112 
113 template <typename... Args>
114 auto join(Args&&... args) -> decltype(joinPath(std::forward<Args>(args)...)) {
115  return joinPath(std::forward<Args>(args)...);
116 }
117 
118 template <typename... Args>
119 auto split(Args&&... args) -> decltype(splitPath(std::forward<Args>(args)...)) {
120  return splitPath(std::forward<Args>(args)...);
121 }
122 
123 
124 template <typename T, typename U>
125 std::vector<boost::filesystem::path> multiPathAppend(const std::vector<T>& initial_locations, const std::vector<U>& suffixes) {
126 
127  using std::vector;
128  using boost::filesystem::path;
129 
130  vector<path> result(initial_locations.size()*suffixes.size());
131 
132  auto pos = result.begin();
133 
134  std::for_each(initial_locations.cbegin(), initial_locations.cend(),
135  [&pos, &suffixes](const T& l) {
136  std::transform(suffixes.cbegin(), suffixes.cend(),
137  pos,
138  [l](const U& s){
139  return path {l} / s;
140  });
141  pos += static_cast<std::ptrdiff_t>(suffixes.size());
142 
143  });
144 
145 
146  return result;
147 }
148 
149 template <typename T>
150 std::vector<boost::filesystem::path> removeDuplicates(const std::vector<T>& path_list) {
151 
152  using boost::filesystem::path;
153 
154  std::unordered_set<std::string> s;
155 
156  std::vector<path> output(path_list.size());
157 
158  auto end = copy_if(path_list.cbegin(), path_list.cend(), output.begin(),
159  [&s](const T& i) {
160  return s.insert(path{i}.string()).second;
161  });
162 
163  output.erase(end, output.end());
164 
165  return output;
166 
167 }
168 
169 
170 } // namespace Path
171 } // namespace Elements
172 
173 #endif // ELEMENTSKERNEL__IMPL_PATH_ICPP_