Replace boost usage

Author: Liastre

src/detail/uri_normalize.cpp

@@ -3,32 +3,23 @@
 // (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
+#include "uri_normalize.hpp"
+#include "uri_percent_encode.hpp"
+#include "algorithm.hpp"
+#include "algorithm_split.hpp"
 #include <iterator>
 #include <vector>
 #include <algorithm>
 
-#ifdef NETWORK_URI_EXTERNAL_BOOST
-#include <boost/algorithm/string/split.hpp>
-#include <boost/algorithm/string/join.hpp>
-namespace network_boost = boost;
-#else  // NETWORK_URI_EXTERNAL_BOOST
-#include "../boost/algorithm/string/split.hpp"
-#include "../boost/algorithm/string/join.hpp"
-#endif  // NETWORK_URI_EXTERNAL_BOOST
-
-#include "uri_normalize.hpp"
-#include "uri_percent_encode.hpp"
-#include "algorithm.hpp"
+using namespace network::algorithm;
+namespace network_detail = network::detail;
 
-namespace network {
-namespace detail {
-std::string normalize_path_segments(string_view path) {
+std::string network_detail::normalize_path_segments(string_view path) {
   std::string result;
 
   if (!path.empty()) {
     std::vector<std::string> path_segments;
-    network_boost::split(path_segments, path,
-                         [](char ch) { return ch == '/'; });
+    split(path_segments, path, '/');
 
     bool last_segment_is_slash = path_segments.back().empty();
     std::vector<std::string> normalized_segments;
@@ -61,12 +52,13 @@ std::string normalize_path_segments(string_view path) {
   return result;
 }
 
-std::string normalize_path(string_view path, uri_comparison_level level) {
+std::string network_detail::normalize_path(string_view path,
+                                   uri_comparison_level level) {
   auto result = path.to_string();
 
   if (uri_comparison_level::syntax_based == level) {
     // case normalization
-    detail::for_each(result, percent_encoded_to_upper<std::string>());
+    for_each(result, percent_encoded_to_upper<std::string>());
 
     // % encoding normalization
     result.erase(detail::decode_encoded_unreserved_chars(std::begin(result),
@@ -79,5 +71,3 @@ std::string normalize_path(string_view path, uri_comparison_level level) {
 
   return result;
 }
-}  // namespace detail
-}  // namespace network

src/detail/uri_resolve.cpp

@@ -5,23 +5,13 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include "uri_resolve.hpp"
-#include <algorithm>
+#include "algorithm_find.hpp"
 
-#ifdef NETWORK_URI_EXTERNAL_BOOST
-#include <boost/algorithm/string/find.hpp>
-#include <boost/algorithm/string/erase.hpp>
-#include <boost/algorithm/string/replace.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-namespace network_boost = boost;
-#else  // NETWORK_URI_EXTERNAL_BOOST
-#include "../boost/algorithm/string/find.hpp"
-#include "../boost/algorithm/string/erase.hpp"
-#include "../boost/algorithm/string/replace.hpp"
-#include "../boost/algorithm/string/predicate.hpp"
-#endif  // NETWORK_URI_EXTERNAL_BOOST
+using namespace network::algorithm;
+namespace network_detail = network::detail;
+
+namespace {
 
-namespace network {
-namespace detail {
 // remove_dot_segments
 inline void remove_last_segment(std::string &path) {
   while (!path.empty()) {
@@ -33,57 +23,64 @@ inline void remove_last_segment(std::string &path) {
   }
 }
 
+inline bool starts_with(std::string const &str, const char *range) {
+  return str.find(range) == 0;
+}
+
 // implementation of http://tools.ietf.org/html/rfc3986#section-5.2.4
 static std::string remove_dot_segments(std::string input) {
   std::string result;
 
   while (!input.empty()) {
-    if (network_boost::starts_with(input, "../")) {
-      network_boost::erase_head(input, 3);
-    } else if (network_boost::starts_with(input, "./")) {
-      network_boost::erase_head(input, 2);
-    } else if (network_boost::starts_with(input, "/./")) {
-      network_boost::replace_head(input, 3, "/");
+    if (starts_with(input, "../")) {
+      input.erase(0, 3);
+    } else if (starts_with(input, "./")) {
+      input.erase(0, 2);
+    } else if (starts_with(input, "/./")) {
+      input.erase(0, 2);
+      input.front() = '/';
     } else if (input == "/.") {
-      network_boost::replace_head(input, 2, "/");
-    } else if (network_boost::starts_with(input, "/../")) {
-      network_boost::erase_head(input, 3);
+      input.erase(0, 1);
+      input.front() = '/';
+    } else if (starts_with(input, "/../")) {
+      input.erase(0, 3);
       remove_last_segment(result);
-    } else if (network_boost::starts_with(input, "/..")) {
-      network_boost::replace_head(input, 3, "/");
+    } else if (starts_with(input, "/..")) {
+      input.erase(0, 2);
+      input.front() = '/';
       remove_last_segment(result);
-    } else if (network_boost::algorithm::all(
-                   input, [](char ch) { return ch == '.'; })) {
+    } else if (all(input, [](char ch) { return ch == '.'; })) {
       input.clear();
     } else {
       int n = (input.front() == '/') ? 1 : 0;
-      auto slash = network_boost::find_nth(input, "/", n);
-      result.append(std::begin(input), std::begin(slash));
-      input.erase(std::begin(input), std::begin(slash));
+      std::string::const_iterator slash = find_nth(input, '/', n);
+      result.append(input.cbegin(), slash);
+      input.erase(std::begin(input), slash);
     }
   }
   return result;
 }
 
-std::string remove_dot_segments(string_view path) {
-  return remove_dot_segments(path.to_string());
+}  // namespace
+
+std::string network_detail::remove_dot_segments(string_view path) {
+  return ::remove_dot_segments(path.to_string());
 }
 
 // implementation of http://tools.ietf.org/html/rfc3986#section-5.2.3
-std::string merge_paths(const uri &base, const uri &reference) {
+std::string network_detail::merge_paths(const uri &base, const uri &reference) {
   std::string result;
 
   if (!base.has_path() || base.path().empty()) {
     result = "/";
   } else {
     const auto &base_path = base.path();
-    auto last_slash = network_boost::find_last(base_path, "/");
-    result.append(std::begin(base_path), std::end(last_slash));
+    auto last_slash = algorithm::find_last(base_path, '/');
+    if (last_slash != base_path.cend()) ++last_slash;
+    result.append(std::begin(base_path), last_slash);
   }
   if (reference.has_path()) {
     result.append(reference.path().to_string());
   }
   return remove_dot_segments(string_view(result));
 }
-}  // namespace detail
-}  // namespace network