Algorithms

Applications/ApplicationsLib/ProjectData.cpp

@@ -18,8 +18,8 @@
 
 #include <logog/include/logog.hpp>
 
+#include "BaseLib/Algorithm.h"
 #include "BaseLib/FileTools.h"
-#include "BaseLib/uniqueInsert.h"
 
 #include "GeoLib/GEOObjects.h"
 #include "MathLib/Curve/CreatePiecewiseLinearCurve.h"

Applications/DataHolderLib/Project.cpp

@@ -11,12 +11,10 @@
 #include "Project.h"
 
 #include <algorithm>
-
 #include <logog/include/logog.hpp>
 
+#include "BaseLib/Algorithm.h"
 #include "BaseLib/FileTools.h"
-#include "BaseLib/uniqueInsert.h"
-
 #include "MeshLib/Mesh.h"
 
 namespace DataHolderLib

Applications/Utils/MeshEdit/NodeReordering.cpp

@@ -18,7 +18,7 @@
 
 #include "Applications/ApplicationsLib/LogogSetup.h"
 
-#include "BaseLib/makeVectorUnique.h"
+#include "BaseLib/Algorithm.h"
 
 #include "MeshLib/IO/readMeshFromFile.h"
 #include "MeshLib/IO/writeMeshToFile.h"

BaseLib/uniqueInsert.h → BaseLib/Algorithm.h

@@ -1,8 +1,5 @@
 /**
  * \file
- * \author Thomas Fischer
- * \date   2011-02-23
- * \brief  Definition of the uniquePushBack function.
  *
  * \copyright
  * Copyright (c) 2012-2018, OpenGeoSys Community (http://www.opengeosys.org)
@@ -15,19 +12,67 @@
 #pragma once
 
 #include <algorithm>
-#include <typeinfo>
+#include <cassert>
 #include <typeindex>
+#include <typeinfo>
 #include "Error.h"
 
 namespace BaseLib
 {
-template <typename Container>
-void uniquePushBack(Container& container,
-                    typename Container::value_type const& element)
+
+/// excludeObjectCopy copies only those objects that position within the source
+/// vector is not in the exclude_positions vector. The implementation of the
+/// algorithm requires that the given positions in exclude_positions are sorted
+/// in ascending order.
+/// @param src_vec the vector of source objects
+/// @param exclude_positions the positions of objects in the source vector that
+/// do not have to be copied
+/// @return vector that contains the copied objects
+template <typename T>
+std::vector<T> excludeObjectCopy(std::vector<T> const& src_vec,
+    std::vector<std::size_t> const& exclude_positions)
 {
-    if (std::find(container.begin(), container.end(), element) ==
-        container.end())
-        container.push_back(element);
+    std::vector<T> dest_vec;
+    if (exclude_positions.empty()) {
+        dest_vec = src_vec;
+        return dest_vec;
+    }
+
+    assert (exclude_positions.back() < src_vec.size());
+
+    std::copy_n(src_vec.cbegin(), exclude_positions[0], std::back_inserter(dest_vec));
+    for (std::size_t i=1; i<exclude_positions.size(); ++i) {
+        std::copy_n(
+            src_vec.cbegin()+exclude_positions[i-1]+1,
+            exclude_positions[i]-(exclude_positions[i-1]+1),
+            std::back_inserter(dest_vec)
+        );
+    }
+    std::copy(src_vec.cbegin()+exclude_positions.back()+1,
+        src_vec.cend(), std::back_inserter(dest_vec));
+
+    return dest_vec;
+}
+
+template <typename T>
+void excludeObjectCopy(std::vector<T> const& src_vec,
+    std::vector<std::size_t> const& exclude_positions,
+    std::vector<T> & dest_vec)
+{
+    dest_vec = excludeObjectCopy(src_vec, exclude_positions);
+}
+
+template <typename InputIt, typename Predicate>
+typename std::iterator_traits<InputIt>::reference findElementOrError(
+    InputIt begin, InputIt end, Predicate predicate,
+    std::string const& error = "")
+{
+    auto it = std::find_if(begin, end, predicate);
+    if (it == end)
+    {
+        OGS_FATAL("Element not found in the input range; %s", error.c_str());
+    }
+    return *it;
 }
 
 //! Inserts the given \c key with the given \c value into the \c map if an entry
@@ -125,4 +170,50 @@ typename Map::mapped_type const& getOrError(Map const& map, Key const& key,
     return it->second;
 }
 
-}  // end namespace BaseLib
+/// Make the entries of the std::vector \c v unique. The remaining entries will
+/// be sorted.
+template <typename T>
+void makeVectorUnique(std::vector<T>& v)
+{
+    std::sort(v.begin(), v.end());
+    auto it = std::unique(v.begin(), v.end());
+    v.erase(it, v.end());
+}
+
+/// Make the entries of the std::vector \c v unique using the given binary
+/// function. The remaining entries will be sorted.
+template <typename T, class Compare>
+void makeVectorUnique(std::vector<T>& v, Compare comp)
+{
+    std::sort(v.begin(), v.end(), comp);
+    auto it = std::unique(v.begin(), v.end());
+    v.erase(it, v.end());
+}
+
+/**
+ *  Reorder a vector by a given index vector.
+ *
+ *  Note: It is good enough in performance for medium size vectors.
+ */
+template <typename ValueType, typename IndexType>
+void reorderVector(std::vector<ValueType>& v,
+                   std::vector<IndexType> const& order)
+{
+    std::vector<ValueType> temp_v(v.size());
+    temp_v.swap(v);
+
+    for (std::size_t i=0; i<order.size(); i++)
+    {
+        std::swap(v[i], temp_v[order[i]]);
+    }
+}
+
+template <typename Container>
+void uniquePushBack(Container& container,
+                    typename Container::value_type const& element)
+{
+    if (std::find(container.begin(), container.end(), element) ==
+        container.end())
+        container.push_back(element);
+}
+}  // namespace BaseLib

BaseLib/Functional.h

@@ -11,7 +11,6 @@
 
 #include <functional>
 #include "baselib_export.h"
-#include "BaseLib/TMPUtil.h"
 
 namespace BaseLib
 {
@@ -101,7 +100,7 @@ template <int... Indices, typename Object, typename MethodClass,
           typename ReturnType, typename... Args>
 std::function<ReturnType(Args...)> easyBind_inner(
     ReturnType (MethodClass::*method)(Args...), Object&& obj,
-    IntegerSequence<Indices...>)
+    std::integer_sequence<int, Indices...>)
 {
     return easyBind_innermost<Indices...>(method, std::forward<Object>(obj));
 }
@@ -110,7 +109,7 @@ template <int... Indices, typename Object, typename MethodClass,
           typename ReturnType, typename... Args>
 std::function<ReturnType(Args...)> easyBind_inner(
     ReturnType (MethodClass::*method)(Args...) const, Object&& obj,
-    IntegerSequence<Indices...>)
+    std::integer_sequence<int, Indices...>)
 {
     return easyBind_innermost<Indices...>(method, std::forward<Object>(obj));
 }
@@ -182,7 +181,7 @@ easyBind(ReturnType (MethodClass::*method)(Args...), Object&& obj)
 {
     return detail::easyBind_inner(
         method, std::forward<Object>(obj),
-        typename GenerateIntegerSequence<sizeof...(Args)>::type{});
+        std::make_integer_sequence<int, sizeof...(Args)>{});
 }
 
 //! \overload
@@ -197,7 +196,7 @@ easyBind(ReturnType (MethodClass::*method)(Args...) const, Object&& obj)
 {
     return detail::easyBind_inner(
         method, std::forward<Object>(obj),
-        typename GenerateIntegerSequence<sizeof...(Args)>::type{});
+        std::make_integer_sequence<int, sizeof...(Args)>{});
 }
 
 //! Wraps a callable object in a std::function.