Add boost algorithms replacement

Author: Liastre

src/detail/algorithm_find.hpp

@@ -0,0 +1,80 @@
+/**
+ * Search algorithms
+ * @author Lobaskin Vasily
+ * @data 31 March 2020
+ * @copyright Boost Software License, Version 1.0
+ */
+
+#pragma once
+
+#include <cstddef>
+
+namespace network {
+namespace algorithm {
+
+template <typename IteratorBegT, typename IteratorEndT, typename RangeT>
+IteratorBegT find_nth(IteratorBegT iteratorBeg, IteratorEndT iteratorEnd,
+                      RangeT symbol, std::size_t pos) {
+  static_assert(std::is_same<IteratorBegT, IteratorEndT>::value,
+                "Iterator types are different");
+
+  if (iteratorBeg > iteratorEnd) {
+    std::swap(iteratorBeg, iteratorEnd);
+  }
+
+  std::size_t currentPos = -1;
+  while (iteratorBeg != iteratorEnd) {
+    if (*iteratorBeg == symbol) {
+      ++currentPos;
+      if (currentPos == pos) break;
+    }
+    ++iteratorBeg;
+  }
+
+  return iteratorBeg;
+}
+
+template <typename IteratorBegT, typename IteratorEndT, typename ConditionT>
+bool all(IteratorBegT iteratorBeg, IteratorEndT iteratorEnd,
+         ConditionT &&condition) {
+  static_assert(std::is_same<IteratorBegT, IteratorEndT>::value,
+                "Iterator types are different");
+
+  if (iteratorBeg > iteratorEnd) {
+    std::swap(iteratorBeg, iteratorEnd);
+  }
+
+  while (iteratorBeg != iteratorEnd) {
+    if (!condition(*iteratorBeg)) return false;
+
+    ++iteratorBeg;
+  }
+
+  return true;
+}
+
+template <typename ContainerT, typename RangeT>
+typename ContainerT::const_iterator find_nth(ContainerT const &str,
+                                             RangeT symbol, std::size_t pos) {
+  return algorithm::find_nth(str.begin(), str.end(), symbol, pos);
+}
+
+template <typename ContainerT, typename RangeT>
+typename ContainerT::const_iterator find_last(ContainerT const &str,
+                                              RangeT symbol) {
+  auto iter = algorithm::find_nth(str.rbegin(), str.rend(), symbol, 0);
+  if (iter == str.rend()) {
+    return str.end();
+  }
+
+  return (++iter).base();
+}
+
+template <typename ContainerT, typename ConditionT>
+bool all(ContainerT const &container, ConditionT &&condition) {
+  return all(container.cbegin(), container.cend(),
+             std::forward<ConditionT>(condition));
+}
+
+}  // namespace algorithm
+}  // namespace network

src/detail/algorithm_split.hpp

@@ -0,0 +1,75 @@
+/**
+ * Search algorithms
+ * @author Lobaskin Vasily
+ * @data 31 March 2020
+ * @copyright Boost Software License, Version 1.0
+ */
+
+#include <type_traits>
+
+namespace network {
+namespace algorithm {
+
+template <typename ContainerT, class SequenceT, typename SplitterT,
+          typename std::enable_if<std::is_fundamental<SplitterT>::value>::type
+              * = nullptr>
+bool split(ContainerT &container, SequenceT const &str, SplitterT symbol) {
+  using PartT = typename ContainerT::value_type;
+  static_assert(std::is_same<typename SequenceT::value_type, SplitterT>::value,
+                "Splitter type doesn't match sequence inner type");
+
+  std::size_t sequenceStart = 0;
+  for (std::size_t i = 0, len = str.size(); i <= len; ++i) {
+    if (str[i] != symbol && i != len) continue;
+
+    std::size_t substrLen = i - sequenceStart;
+    if (substrLen > 0) {
+      PartT part{str.cbegin() + sequenceStart, str.cbegin() + i};
+      container.emplace_back(std::move(part));
+    } else {
+      container.emplace_back(PartT{});
+    }
+    sequenceStart = i + 1;
+  }
+
+  return true;
+}
+
+template <typename ContainerT, class SequenceT, typename SplitterT,
+          typename std::enable_if<!std::is_fundamental<SplitterT>::value>::type
+              * = nullptr>
+bool split(ContainerT &container, SequenceT const &str, SplitterT splitter) {
+  using PartT = typename ContainerT::value_type;
+  static_assert(
+      std::is_same<typename ContainerT::value_type, std::string>::value,
+      "Invalid container type, only string is supported");
+
+  bool isEqual = false;
+  std::size_t sequenceLen = splitter.size();
+  std::size_t sequenceStart = 0;
+  for (std::size_t i = 0, len = str.size(); i <= len; ++i) {
+    isEqual = true;
+    for (std::size_t j = 0; j < sequenceLen; ++j) {
+      if (str[i + j] != splitter[j]) {
+        isEqual = false;
+        break;
+      }
+    }
+    if (!isEqual && i != len) continue;
+
+    std::size_t substrLen = i - sequenceStart;
+    if (substrLen > 0) {
+      PartT part{str.cbegin() + sequenceStart, str.cbegin() + i};
+      container.emplace_back(std::move(part));
+    } else {
+      container.emplace_back(PartT{});
+    }
+    sequenceStart = i + sequenceLen;
+    i += sequenceLen - 1;
+  }
+
+  return true;
+}
+
+}  // namespace algorithm
+}  // namespace network