Merge pull request #1680 from evoskuil/master

Add and test new part() collection function.

Author: evoskuil

include/bitcoin/system/data/collection.hpp

@@ -111,6 +111,11 @@ template <typename Left, typename Right>
 constexpr bool is_intersecting(const typename Left::const_iterator& begin,
     const typename Left::const_iterator& end, const Right& right) NOEXCEPT;
 
+/// Move all elements from positions at or above found element position.
+template <typename Collection>
+bool part(Collection& from, Collection& to,
+    const typename Collection::value_type& element) NOEXCEPT;
+
 /// Reverse the order of collection elements.
 /// Use reverse_view for reverse iteration.
 template <typename Collection>

include/bitcoin/system/impl/data/collection.ipp

@@ -69,7 +69,6 @@ constexpr binary_search(const Collection& list,
     return negative_one;
 }
 
-// C++17: Parallel policy for std::transform.
 template <typename To, typename From>
 inline To projection(const From& source) NOEXCEPT
 {
@@ -85,7 +84,6 @@ inline To projection(const From& source) NOEXCEPT
     return out;
 }
 
-// C++17: Parallel policy for std::equal.
 template <typename Left, typename Right>
 constexpr bool deep_equal(const Left& left, const Right& right) NOEXCEPT
 {
@@ -100,7 +98,6 @@ constexpr bool deep_equal(const Left& left, const Right& right) NOEXCEPT
         });
 }
 
-// C++17: Parallel policy for std::any_of.
 template <typename Collection, typename Element>
 constexpr bool contains(const Collection& list,
     const Element& element) NOEXCEPT
@@ -109,7 +106,6 @@ constexpr bool contains(const Collection& list,
         std::end(list);
 }
 
-// C++17: Parallel policy for std::find_if.
 template <typename Collection>
 typename Collection::difference_type
 constexpr find_pair_position(const Collection& list,
@@ -125,7 +121,6 @@ constexpr find_pair_position(const Collection& list,
         std::distance(std::begin(list), position);
 }
 
-// C++17: Parallel policy for std::find.
 template <typename Collection>
 typename Collection::difference_type
 constexpr find_position(const Collection& list,
@@ -172,7 +167,6 @@ inline pop_front(Collection& stack) NOEXCEPT
     return element;
 }
 
-// C++17: Parallel policy for std::sort, std::unique.
 template <typename Collection>
 constexpr bool is_distinct(Collection&& list) NOEXCEPT
 {
@@ -187,14 +181,12 @@ constexpr bool is_distinct(const Collection& list) NOEXCEPT
     return is_distinct(copy);
 }
 
-// C++17: Parallel policy for std::is_sorted.
 template <typename Collection>
 constexpr bool is_sorted(const Collection& list) NOEXCEPT
 {
     return std::is_sorted(std::begin(list), std::end(list));
 }
 
-// C++17: Parallel policy for std::sort, std::erase.
 template <typename Collection>
 constexpr void distinct(Collection& list) NOEXCEPT
 {
@@ -244,7 +236,6 @@ constexpr bool is_intersecting(const Left& left, const Right& right) NOEXCEPT
     return is_intersecting<Left>(std::begin(left), std::end(left), right);
 }
 
-// C++17: Parallel policy for std::find_first_of.
 template <typename Left, typename Right>
 constexpr bool is_intersecting(const typename Left::const_iterator& begin,
     const typename Left::const_iterator& end, const Right& right) NOEXCEPT
@@ -253,7 +244,26 @@ constexpr bool is_intersecting(const typename Left::const_iterator& begin,
         std::end(right)) != end;
 }
 
-// C++17: Parallel policy for std::reverse.
+template <typename Collection>
+bool part(Collection& from, Collection& to,
+    const typename Collection::value_type& element) NOEXCEPT
+{
+    using Type = typename Collection::value_type;
+    const auto it = std::find_if(from.begin(), from.end(),
+        [&](const Type& value) noexcept
+        {
+            return value == element;
+        });
+
+    if (it == from.end())
+        return false;
+
+    to.insert(to.end(), std::make_move_iterator(it),
+        std::make_move_iterator(from.end()));
+    from.erase(it, from.end());
+    return true;
+}
+
 template <typename Collection>
 inline Collection reverse(Collection&& list) NOEXCEPT
 {
@@ -267,7 +277,6 @@ inline Collection reverse_copy(const Collection& list) NOEXCEPT
     return reverse(Collection{ list });
 }
 
-// C++17: Parallel policy for std::sort.
 template <typename Collection>
 constexpr void sort(Collection& list) NOEXCEPT
 {
@@ -287,7 +296,6 @@ inline Collection sort_copy(const Collection& list) NOEXCEPT
     return sort(Collection{ list });
 }
 
-// C++17: Parallel policy for std::equal.
 template <typename Collection>
 constexpr bool starts_with(const typename Collection::const_iterator& begin,
     const typename Collection::const_iterator& end,

test/data/collection.cpp

@@ -88,7 +88,7 @@ BOOST_AUTO_TEST_CASE(limits__binary_search_native__sorted_contained__expected)
 BOOST_AUTO_TEST_CASE(limits__binary_search_native__reverse_sorted_contained__unlucky)
 {
     const std::string unsorted = "zyxwvutscba";
-    const auto value = 'x';
+    constexpr auto value = 'x';
     BOOST_REQUIRE_EQUAL(binary_search(unsorted, value), -1);
 }
 
@@ -173,7 +173,7 @@ BOOST_AUTO_TEST_CASE(collection__pop__empty__empty_default)
 
 BOOST_AUTO_TEST_CASE(collection__pop__single__empty_expected)
 {
-    const uint8_t expected = 42u;
+    constexpr uint8_t expected = 42u;
     data_chunk stack{ expected };
     const auto value = pop(stack);
     BOOST_REQUIRE(stack.empty());
@@ -203,7 +203,7 @@ BOOST_AUTO_TEST_CASE(collection__pop_front__empty__empty_default)
 
 BOOST_AUTO_TEST_CASE(collection__pop_front__single__empty_expected)
 {
-    const uint8_t expected = 42u;
+    constexpr uint8_t expected = 42u;
     data_queue queue{ expected };
     const auto value = pop_front(queue);
     BOOST_REQUIRE(queue.empty());
@@ -212,7 +212,7 @@ BOOST_AUTO_TEST_CASE(collection__pop_front__single__empty_expected)
 
 BOOST_AUTO_TEST_CASE(collection__pop_front__multiple__popped_expected)
 {
-    const uint8_t expected_value = 42u;
+    constexpr uint8_t expected_value = 42u;
     data_queue queue{ expected_value, 0, 1, 2, 3 };
     const data_queue expected_queue{ 0, 1, 2, 3 };
     const auto value = pop_front(queue);
@@ -435,6 +435,98 @@ BOOST_AUTO_TEST_CASE(collection__difference__subtrahend_subset__expected)
     BOOST_REQUIRE_EQUAL(difference(minuend, subtrahend), expected);
 }
 
+// part
+
+BOOST_AUTO_TEST_CASE(collection__part__vector__true)
+{
+    std::vector<int> from = { 1, 2, 4, 7, 8, 3, 1, 5, 3 };
+    std::vector<int> to{};
+    BOOST_REQUIRE(part(from, to, 3));
+    BOOST_REQUIRE_EQUAL(from, (std::vector<int>{1, 2, 4, 7, 8}));
+    BOOST_REQUIRE_EQUAL(to, (std::vector<int>{3, 1, 5, 3}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__list__true)
+{
+    std::list<int> from = { 1, 2, 4, 7, 8, 3, 1, 5, 3 };
+    std::list<int> to{};
+    BOOST_REQUIRE(part(from, to, 3));
+    BOOST_REQUIRE(from == (std::list<int>{1, 2, 4, 7, 8}));
+    BOOST_REQUIRE(to == (std::list<int>{3, 1, 5, 3}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__deque__true)
+{
+    std::deque<int> from = { 1, 2, 4, 7, 8, 3, 1, 5, 3 };
+    std::deque<int> to{};
+    BOOST_REQUIRE(part(from, to, 3));
+    BOOST_REQUIRE(from == (std::deque<int>{1, 2, 4, 7, 8}));
+    BOOST_REQUIRE(to == (std::deque<int>{3, 1, 5, 3}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__vector_empty__false)
+{
+    std::vector<int> from{};
+    std::vector<int> to{};
+    BOOST_REQUIRE(!part(from, to, 3));
+    BOOST_REQUIRE_EQUAL(from, (std::vector<int>{}));
+    BOOST_REQUIRE_EQUAL(to, (std::vector<int>{}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__vector_no_equal__false)
+{
+    std::vector<int> from = { 1, 2, 4, 5 };
+    std::vector<int> to{};
+    BOOST_REQUIRE(!part(from, to, 3));
+    BOOST_REQUIRE_EQUAL(from, (std::vector<int>{1, 2, 4, 5}));
+    BOOST_REQUIRE_EQUAL(to, (std::vector<int>{}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__list_first_equal__true)
+{
+    std::list<int> from = { 3, 6, 7, 8 };
+    std::list<int> to{};
+    BOOST_REQUIRE(part(from, to, 3));
+    BOOST_REQUIRE(from == (std::list<int>{}));
+    BOOST_REQUIRE(to == (std::list<int>{3, 6, 7, 8}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__vector_non_empty_to__true)
+{
+    std::vector<int> from = { 1, 3, 4, 5 };
+    std::vector<int> to = { 10, 11 };
+    BOOST_REQUIRE(part(from, to, 3));
+    BOOST_REQUIRE_EQUAL(from, (std::vector<int>{1}));
+    BOOST_REQUIRE_EQUAL(to, (std::vector<int>{10, 11, 3, 4, 5}));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__string_list__true)
+{
+    string_list from = { "apple", "date", "banana", "cherry" };
+    string_list to{};
+    BOOST_REQUIRE(part(from, to, std::string("date")));
+    BOOST_REQUIRE_EQUAL(from, (string_list{ "apple" }));
+    BOOST_REQUIRE_EQUAL(to, (string_list{ "date", "banana", "cherry" }));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__string_list_first_equal__true)
+{
+    string_list from = { "apple", "banana", "cherry", "date" };
+    string_list to{};
+    BOOST_REQUIRE(part(from, to, std::string("apple")));
+    BOOST_REQUIRE_EQUAL(from, (string_list{}));
+    BOOST_REQUIRE_EQUAL(to, (string_list{ "apple", "banana", "cherry", "date" }));
+}
+
+BOOST_AUTO_TEST_CASE(collection__part__string_list_last_equal__true)
+{
+    string_list from = { "banana", "cherry", "date", "apple" };
+    string_list to{};
+    BOOST_REQUIRE(part(from, to, std::string("apple")));
+    BOOST_REQUIRE_EQUAL(from, (string_list{ "banana", "cherry", "date" }));
+    BOOST_REQUIRE_EQUAL(to, (string_list{ "apple" }));
+}
+
 // reverse
 
 BOOST_AUTO_TEST_CASE(collection__reverse_move__empty__empty)
@@ -444,7 +536,7 @@ BOOST_AUTO_TEST_CASE(collection__reverse_move__empty__empty)
 
 BOOST_AUTO_TEST_CASE(collection__reverse_move__single__unchanged)
 {
-    const uint8_t expected = 42;
+    constexpr uint8_t expected = 42;
     BOOST_REQUIRE_EQUAL(reverse(data_chunk{ expected }).front(), expected);
 }
 
@@ -472,7 +564,7 @@ BOOST_AUTO_TEST_CASE(collection__sort_move__empty__empty)
 
 BOOST_AUTO_TEST_CASE(collection__sort_move__single__unchanged)
 {
-    const uint8_t expected = 42;
+    constexpr uint8_t expected = 42;
     BOOST_REQUIRE_EQUAL(sort(data_chunk{ expected }).front(), expected);
 }