[Core] Introducing proper insert method to PointerVectorSet

kratos/containers/pointer_vector_set.h

@@ -27,7 +27,7 @@
 // Project includes
 #include "includes/define.h"
 #include "includes/serializer.h"
-#include "containers/set_identity_function.h"
+#include "containers/set_address_identity_function.h"
 
 namespace Kratos
 {
@@ -63,7 +63,7 @@ namespace Kratos
  * @author Pooyan Dadvand
  */
 template<class TDataType,
-         class TGetKeyType = SetIdentityFunction<TDataType>,
+         class TGetKeyType = SetAddressIdentityFunction<TDataType>,
          class TCompareType = std::less<decltype(std::declval<TGetKeyType>()(std::declval<TDataType>()))>,
          class TEqualType = std::equal_to<decltype(std::declval<TGetKeyType>()(std::declval<TDataType>()))>,
          class TPointerType = typename TDataType::Pointer,
@@ -126,8 +126,8 @@ class PointerVectorSet final
     PointerVectorSet(TInputIteratorType First, TInputIteratorType Last, size_type NewMaxBufferSize = 1)
     : mSortedPartSize(size_type()), mMaxBufferSize(NewMaxBufferSize)
     {
-    for (; First != Last; ++First)
-        insert(begin(), *First);
+        mData.reserve(std::distance(First, Last));
+        insert(First, Last);
     }
 
     /**
@@ -136,7 +136,7 @@ class PointerVectorSet final
      */
     PointerVectorSet(const PointerVectorSet& rOther)
         :  mData(rOther.mData), mSortedPartSize(rOther.mSortedPartSize), mMaxBufferSize(rOther.mMaxBufferSize) {}
-    
+
     /**
      * @brief Constructs a PointerVectorSet from a container.
      * @details This constructor initializes a PointerVectorSet with elements from a container.
@@ -558,54 +558,108 @@ class PointerVectorSet final
             mSortedPartSize = mData.size();
     }
 
-    /**
-     * @brief Inserts a pointer at the specified position.
-     * @details This function inserts a given pointer at the specified position in the set. It also maintains
-     * the sorting order and updates mSortedPartSize if necessary.
-     * @param Position An iterator pointing to the position where the pointer should be inserted.
-     * @param pData The pointer to be inserted.
+     /**
+     * @brief Inserts a pointer.
+     * @details This function inserts a given pointer such that the resulting PointerVectorSet
+     * is kept sorted. If there exists already a pointer with a key same as the key of the value, then
+     * this will return iterator of that existing pointer (The value will not be inserted.)
+     * @param value The pointer to be inserted.
      * @return An iterator pointing to the inserted element.
      */
-    iterator insert(iterator Position, const TPointerType pData)
-    {
-        ptr_iterator sorted_part_end;
-
-        key_type key = KeyOf(*pData);
-
-        if (mData.size() - mSortedPartSize >= mMaxBufferSize) {
-            Sort();
-            sorted_part_end = mData.end();
-        } else
-            sorted_part_end = mData.begin() + mSortedPartSize;
-
-        ptr_iterator i(std::lower_bound(mData.begin(), sorted_part_end, key, CompareKey()));
-        if (i == sorted_part_end) {
-            mSortedPartSize++;
-            return mData.insert(sorted_part_end, pData);
+    iterator insert(const TPointerType& value)
+    {
+        auto itr_pos = std::lower_bound(mData.begin(), mData.end(), KeyOf(*value), CompareKey());
+        if (itr_pos == mData.end()) {
+            // the position to insert is at the end.
+            mData.push_back(value);
+            return iterator(mData.end() - 1);
+        } else if (EqualKeyTo(KeyOf(*value))(*itr_pos)) {
+            // already found existing element with the same key, hence returning the existing element.
+            return iterator(itr_pos);
+        } else {
+            // insert the new value before the itr_pos.
+            return mData.insert(itr_pos, value);
         }
+    }
 
-        if (!EqualKeyTo(key)(*i))
-            if ((i = std::find_if(sorted_part_end, mData.end(), EqualKeyTo(key))) == mData.end()) {
-                mData.push_back(pData);
+    /**
+     * @brief Inserts a pointer at the specified position.
+     * @details This function inserts a given pointer. If the given position_hint is valid, then
+     * it uses that to insert the value, otherwise the position_hint is discarded to maintain the dataset
+     * sorted. If there is an existing element with the same key as in the value, then an iterator for
+     * the existing element is returned.
+     * @param position_hint An iterator pointing to the position where the pointer may be inserted.
+     * @param value The pointer to be inserted.
+     * @return An iterator pointing to the inserted element.
+     */
+    iterator insert(const_iterator position_hint, const TPointerType& value)
+    {
+        if (empty()) {
+            // the dataset is empty. So use push back.
+            mData.push_back(value);
+            return iterator(mData.end() - 1);
+        } else if (position_hint == cend()) {
+            // trying to insert at the end.
+            if (KeyOf(*(position_hint - 1)) < KeyOf(*value)) {
+                // key at the position hint is less than the value of key. Hence position hint
+                // is valid. So using the push back.
+                mData.push_back(value);
                 return iterator(mData.end() - 1);
+            } else {
+                // given position is invalid. Hence, discarding the hint.
+                return insert(value);
             }
-
-        *i = pData;
-        return i;
+        } else if (EqualKeyTo(KeyOf(*position_hint))(*ptr_begin())) {
+            // trying to insert at the front.
+            if (KeyOf(*value) < KeyOf(*position_hint)) {
+                // key at the position hint is greater than the value of key. Hence position hint
+                // is valid. So using the push back.
+                return mData.insert(mData.begin(), value);
+            } else {
+                // given position is invalid. Hence, discarding the hint.
+                return insert(value);
+            }
+        } else {
+            // trying to insert at an arbitrary position.
+            if (KeyOf(*value) < KeyOf(*position_hint) && (KeyOf(*(position_hint - 1)) < KeyOf(*value))) {
+                return mData.insert(mData.begin() + (position_hint - cbegin()), value);
+            } else {
+                // given position is invalid. Hence, discarding the hint.
+                return insert(value);
+            }
+        }
     }
 
     /**
      * @brief Insert elements from a range of iterators.
-     * @details This function inserts elements from a range defined by the iterators `First` and `Last`
-     * into the set. It uses the `insert` function to insert each element.
-     * @param First An input iterator pointing to the beginning of the range to insert.
-     * @param Last An input iterator pointing to the end of the range to insert.
+     * @details This function inserts element pointers from a range defined by the iterators `first` and `last`
+     * into the set. This will not insert any elements in the range, if there exists an element with a key
+     * which is equal to an element's key in the input range.
+     * @param first An input iterator pointing to the beginning of the range to insert.
+     * @param last An input iterator pointing to the end of the range to insert.
      */
     template <class InputIterator>
-    void insert(InputIterator First, InputIterator Last)
+    void insert(InputIterator first, InputIterator last)
     {
-        for (; First != Last; ++First)
-            insert(begin(), *First);
+        // first sorts the input iterators and make the input unique.
+        std::sort(first, last, CompareKey());
+        auto new_last = std::unique(first, last, EqualKeyTo());
+
+        if (empty()) {
+            for (; first != new_last; ++first) {
+                mData.push_back(*first);
+            }
+        } else {
+            auto p_current_itr = mData.begin();
+            // now add the new elements
+            for (; first != new_last; ++first) {
+                // find the lower bound element.
+                p_current_itr = std::lower_bound(p_current_itr, mData.end(), KeyOf(**first), CompareKey());
+                if (!EqualKeyTo(KeyOf(**first))(*p_current_itr)) {
+                    p_current_itr = mData.insert(p_current_itr, *first);
+                }
+            }
+        }
     }
 
     /**
@@ -789,32 +843,32 @@ class PointerVectorSet final
     /**
      * @brief Get the maximum size of buffer used in the container
      */
-    size_type GetMaxBufferSize() const 
+    size_type GetMaxBufferSize() const
     {
         return mMaxBufferSize;
     }
 
-    /** 
+    /**
      * @brief Set the maximum size of buffer used in the container.
      * @details This container uses a buffer which keep data unsorted. After buffer size arrived to the MaxBufferSize it will sort all container and empties buffer.
-     * @param NewSize Is the new buffer maximum size. 
+     * @param NewSize Is the new buffer maximum size.
      */
     void SetMaxBufferSize(const size_type NewSize)
     {
         mMaxBufferSize = NewSize;
     }
 
     /**
-     * @brief Get the sorted part size of buffer used in the container. 
+     * @brief Get the sorted part size of buffer used in the container.
      */
-    size_type GetSortedPartSize() const 
+    size_type GetSortedPartSize() const
     {
         return mSortedPartSize;
     }
 
-    /** 
+    /**
      * @brief Set the sorted part size of buffer used in the container.
-     * @param NewSize Is the new buffer maximum size. 
+     * @param NewSize Is the new buffer maximum size.
      */
     void SetSortedPartSize(const size_type NewSize)
     {
@@ -980,10 +1034,10 @@ class PointerVectorSet final
 
     /// The data container holding the elements.
     TContainerType mData;
-    
+
     /// The size of the sorted portion of the data.
     size_type mSortedPartSize;
-    
+
     /// The maximum buffer size for data storage.
     size_type mMaxBufferSize;
 

kratos/containers/set_address_identity_function.h

@@ -0,0 +1,70 @@
+//    |  /           |
+//    ' /   __| _` | __|  _ \   __|
+//    . \  |   (   | |   (   |\__ `
+//   _|\_\_|  \__,_|\__|\___/ ____/
+//                   Multi-Physics
+//
+//  License:         BSD License
+//                   Kratos default license: kratos/license.txt
+//
+//  Main authors:    Pooyan Dadvand
+//                   Suneth Warnakulasuriya
+//
+//
+
+#pragma once
+
+// System includes
+#include <functional>
+
+// External includes
+
+// Project includes
+
+namespace Kratos
+{
+///@name Kratos Classes
+///@{
+
+/**
+ * @class SetAddressIdentityFunction
+ * @brief A functor that serves as the identity function for memory locations.
+ * @details This class provides two overloaded operator() functions, one for non-const objects
+ * and another for const objects. The operator() returns the input objects memory location as it is,
+ * effectively acting as an identity function for address.
+ * The purpose of this functor is to allow objects' memory locations to be used as keys in sets or other
+ * containers that require comparison. By using this functor, you can avoid defining
+ * custom comparison functions or operators when the object itself can be considered
+ * for comparison.
+ * @tparam TDataType The data type of the object that the functor operates on.
+ * @author Pooyan Dadvand
+ * @author Suneth Warnakulasuriya
+ */
+template<class TDataType>
+class SetAddressIdentityFunction
+{
+public:
+    /**
+     * @brief Operator that returns a non-const reference pointer to the input object.
+     * @param data The input object of type TDataType.
+     * @return A non-const reference pointer to the same object as provided in the parameter.
+     */
+    TDataType* operator()(TDataType& data)
+    {
+        return &data;
+    }
+
+    /**
+     * @brief Operator that returns a const reference pointer to the input object.
+     * @param data The input object of type TDataType.
+     * @return A const reference pointer to the same object as provided in the parameter.
+     */
+    TDataType const * operator()(const TDataType& data) const
+    {
+        return &data;
+    }
+};
+
+///@}
+
+}  // namespace Kratos.