34 std::vector<T>
const& src_vec,
35 std::vector<std::size_t>
const& exclude_positions)
37 std::vector<T> dest_vec;
38 if (exclude_positions.empty())
44 assert(exclude_positions.back() < src_vec.size());
46 std::copy_n(src_vec.cbegin(), exclude_positions[0],
47 std::back_inserter(dest_vec));
48 for (std::size_t i = 1; i < exclude_positions.size(); ++i)
50 std::copy_n(src_vec.cbegin() + exclude_positions[i - 1] + 1,
51 exclude_positions[i] - (exclude_positions[i - 1] + 1),
52 std::back_inserter(dest_vec));
54 std::copy(src_vec.cbegin() + exclude_positions.back() + 1, src_vec.cend(),
55 std::back_inserter(dest_vec));
62 std::vector<std::size_t>
const& exclude_positions,
63 std::vector<T>& dest_vec)
68 template <
typename InputIt,
typename Predicate>
70 InputIt begin, InputIt end, Predicate predicate,
71 std::string
const& error =
"")
73 auto it = std::find_if(begin, end, predicate);
76 OGS_FATAL(
"Element not found in the input range; {:s}", error);
87 template <
typename Map,
typename Key,
typename Value>
90 std::string
const& error_message)
92 auto const inserted = map.emplace(key, std::forward<Value>(value));
95 OGS_FATAL(
"{:s} Key `{:s}' already exists.", error_message,
96 std::to_string(key.hash_code()));
105 template <
typename Map,
typename Key,
typename Value>
107 std::string
const& error_message)
109 auto const inserted = map.emplace(key, std::forward<Value>(value));
110 if (!inserted.second)
112 OGS_FATAL(
"{:s} Key `{:s}' already exists.", error_message, key);
120 template <
typename Map,
typename Key,
typename Value>
122 std::string
const& error_message)
124 auto value_compare = [&value](
typename Map::value_type
const& elem)
125 {
return value == elem.second; };
127 if (std::find_if(map.cbegin(), map.cend(), value_compare) != map.cend())
129 OGS_FATAL(
"{:s} Value `{:s}' already exists.", error_message,
130 std::to_string(value));
133 auto const inserted = map.emplace(key, std::forward<Value>(value));
134 if (!inserted.second)
136 OGS_FATAL(
"{:s} Key `{:s}' already exists.", error_message,
137 std::to_string(key));
146 template <
typename Map,
typename Key>
147 typename Map::mapped_type&
getOrError(Map& map, Key
const& key,
148 std::string
const& error_message)
150 auto it = map.find(key);
153 if constexpr (std::is_convertible<Key, std::string>::value)
155 OGS_FATAL(
"{:s} Key `{:s}' does not exist.", error_message, key);
159 OGS_FATAL(
"{:s} Key `{:s}' does not exist.", error_message,
160 std::to_string(key));
167 template <
typename Map,
typename Key>
168 typename Map::mapped_type
const&
getOrError(Map
const& map, Key
const& key,
169 std::string
const& error_message)
171 auto it = map.find(key);
174 if constexpr (std::is_convertible<Key, std::string>::value)
176 OGS_FATAL(
"{:s} Key `{:s}' does not exist.", error_message, key);
180 OGS_FATAL(
"{:s} Key `{:s}' does not exist.", error_message,
181 std::to_string(key));
191 template <
typename Container,
typename Predicate>
193 Container
const& container,
194 Predicate&& predicate,
195 std::string
const& error_message)
197 auto it = std::find_if(begin(container), end(container), predicate);
198 if (it == end(container))
200 OGS_FATAL(
"Could not find element matching the predicate: {:s}",
208 template <
typename T>
211 std::sort(v.begin(), v.end());
212 auto it = std::unique(v.begin(), v.end());
213 v.erase(it, v.end());
218 template <
typename T,
class Compare>
221 std::sort(v.begin(), v.end(), comp);
222 auto it = std::unique(v.begin(), v.end());
223 v.erase(it, v.end());
231 template <
typename ValueType,
typename IndexType>
233 std::vector<IndexType>
const& order)
235 std::vector<ValueType> temp_v(v.size());
238 for (std::size_t i = 0; i < order.size(); i++)
240 std::swap(v[i], temp_v[order[i]]);
244 template <
typename Container>
246 typename Container::value_type
const& element)
248 if (std::find(container.begin(), container.end(), element) ==
251 container.push_back(element);
255 template <
typename Container>
257 typename Container::value_type
const& element)
259 return std::find(container.begin(), container.end(), element) !=
263 template <
typename Container,
typename Predicate>
264 bool containsIf(Container
const& container, Predicate&& predicate)
266 return std::find_if(container.begin(), container.end(), predicate) !=
270 template <
typename Container>
272 Container
const& container,
typename Container::value_type
const& element)
275 std::find_if_not(container.begin(), container.end(),
276 [&element](
typename Container::value_type
const& e)
277 { return e == element; });
278 return it == container.end() ? std::nullopt : std::make_optional(*it);
286 template <
typename Container>
288 typename Container::value_type
const& element)
290 auto const it = std::find(container.begin(), container.end(), element);
291 if (it == container.end())
293 return std::numeric_limits<std::size_t>::max();
295 return std::distance(container.begin(), it);
299 template <
typename T1,
typename T2>
301 std::vector<T2*>
const& dependent_items)
303 for (
auto dependent_item : dependent_items)
305 delete dependent_item;
307 for (
auto item : items)
std::optional< typename Container::value_type > findFirstNotEqualElement(Container const &container, typename Container::value_type const &element)
Map::mapped_type & getOrError(Map &map, Key const &key, std::string const &error_message)
std::size_t findIndex(Container const &container, typename Container::value_type const &element)
bool contains(Container const &container, typename Container::value_type const &element)
void insertIfKeyUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
bool containsIf(Container const &container, Predicate &&predicate)
void insertIfTypeIndexKeyUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
void uniquePushBack(Container &container, typename Container::value_type const &element)
void reorderVector(std::vector< ValueType > &v, std::vector< IndexType > const &order)
void insertIfKeyValueUniqueElseError(Map &map, Key const &key, Value &&value, std::string const &error_message)
std::vector< T > excludeObjectCopy(std::vector< T > const &src_vec, std::vector< std::size_t > const &exclude_positions)
void makeVectorUnique(std::vector< T > &v)
void cleanupVectorElements(std::vector< T1 * > const &items, std::vector< T2 * > const &dependent_items)
Container::value_type const & getIfOrError(Container const &container, Predicate &&predicate, std::string const &error_message)
std::iterator_traits< InputIt >::reference findElementOrError(InputIt begin, InputIt end, Predicate predicate, std::string const &error="")
void copy(PETScVector const &x, PETScVector &y)