Add limited span support

Author: fbdtemme

CHANGELOG.md

@@ -2,13 +2,14 @@
 
 ## v0.5.0
 
-* Rename event_consumer methods from (begin|end)\_(list|dict) to (begin|end)\_(list|dict).
-  This makes naming more consistent.
-* Add more benchmarks
+* More consisten naming by changing event_consumer methods from (begin|end)\_(list|dict)
+  to (begin|end)\_(list|dict).
+* Add more benchmarks.
 * Disable contract checks in release build for improved performance.
 * Fix parsing from a pair of InputItererators.
 * Add string_parsing_mode options to push_parser to allow parsing strings to string_view. 
 * Add experimental SSE4.1 and AVX2 integer parsing backends. Enable SWAR integer parsing by default. 
+* Add limited std::span serialization/deserialization support.
 
 ## v0.4.0
 

README.md

@@ -18,7 +18,7 @@
 [**Integration**](#Integration) |
 [**License**](#License)
 
-A header-only C++20 bencode serialization/deserialization library. Inspired by toa
+A header-only C++20 bencode serialization/deserialization library.
 
 ## Features
 
@@ -38,9 +38,11 @@ A header-only C++20 bencode serialization/deserialization library. Inspired by t
   stack-based buffer overflow attacks. Integer parsing throws when overflows are encountered.
 * **Speed**. While not the primary goal of this project this library provides optimized integer parsing with
   SWAR techniques. Benchmarks show this library performs well in comparison with other libraries
-  
-## Status
+* **Well-tested**. This project achieves 95% testing coverage. 
+  We also run Sanitizers in a CI pipeline to check for leaks and undefined-behavior.
 
+## Status
+ 
 This library is under active development. The API may change at any release prior to 1.0.0.
 Versioning follows the Semantic Versioning Specification.
 

external/arvidn-libtorrent.cmake

@@ -11,4 +11,5 @@ else()
             GIT_TAG        RC_2_0
     )
     FetchContent_MakeAvailable(libtorrent-rasterbar)
-endif()
+endif()
+

include/bencode/detail/bvalue/conversion.hpp

@@ -2,6 +2,7 @@
 #pragma once
 
 #include <nonstd/expected.hpp>
+#include <span>
 
 #include "bencode/detail/symbol.hpp"
 #include "bencode/detail/utils.hpp"
@@ -40,35 +41,54 @@ convert_from_bvalue_string_impl(customization_point_type<const char*>,
     return s.c_str();
 }
 
-// Conversion via iterators pair constructor
+// Conversion to T via pair of iterators
 
-template <typename T, typename Policy>
+template <typename T, basic_bvalue_instantiation U, typename Policy = typename std::remove_cvref_t<U>::policy_type>
     requires
-        std::constructible_from<
-                typename policy_string_t<Policy>::value_type, rng::range_value_t<T>> &&
-        std::constructible_from<
-                policy_string_t<Policy>, rng::iterator_t<T>, rng::sentinel_t<T>>
+        std::constructible_from<typename policy_string_t<Policy>::value_type,
+                                 rng::range_value_t<T>> &&
+        std::constructible_from<T, rng::iterator_t<policy_string_t<Policy>>,
+                                   rng::sentinel_t<policy_string_t<Policy>>>
 constexpr nonstd::expected<T, conversion_errc>
 convert_from_bvalue_string_impl(customization_point_type<T>,
-                                const basic_bvalue<Policy>& b,
-                                priority_tag<1>) noexcept
+                                U&& b,
+                                priority_tag<2>) noexcept
 {
     if (!holds_string(b)) [[unlikely]]
         return nonstd::make_unexpected(conversion_errc::not_string_type);
 
-    const auto& bstring = get_string(b);
+    auto& bstring = get_string(b);
     try { return T(rng::begin(bstring), rng::end(bstring)); }
     catch (...) { return nonstd::make_unexpected(conversion_errc::construction_error); }
 }
 
+// Conversion to T via pointer and size
+
+template <typename T, basic_bvalue_instantiation U, typename Policy = typename std::remove_cvref_t<U>::policy_type>
+    requires rng::contiguous_range<policy_string_t<Policy>> &&
+             std::constructible_from<T, rng::range_value_t<policy_string_t<Policy>>*,
+                                         rng::range_size_t<policy_string_t<Policy>>>
+constexpr nonstd::expected<T, conversion_errc>
+convert_from_bvalue_string_impl(customization_point_type<T>,
+                                U&& b,
+                                priority_tag<3>) noexcept
+{
+    if (!holds_string(b)) [[unlikely]]
+        return nonstd::make_unexpected(conversion_errc::not_string_type);
+
+    auto& bstring = get_string(b);
+    try { return T(rng::data(bstring), rng::size(bstring)); }
+    catch (...) { return nonstd::make_unexpected(conversion_errc::construction_error); }
+}
+
 // Conversion through std::string_view.
 
-template <typename T, typename Policy>
+template <typename T, basic_bvalue_instantiation U, typename Policy = typename std::remove_cvref_t<U>::policy_type>
     requires std::constructible_from<T, std::string_view> &&
              std::convertible_to<policy_string_t<Policy>, std::string_view>
 constexpr nonstd::expected<T, conversion_errc>
 convert_from_bvalue_string_impl(customization_point_type<T>,
-                                const basic_bvalue<Policy>& b,
+                                U&& b,
                                 priority_tag<0>) noexcept
 
 {
@@ -79,23 +99,23 @@ convert_from_bvalue_string_impl(customization_point_type<T>,
 }
 
 
-// Conversion of  byte stringsauto
+// Conversion of  byte strings auto
 
-template <typename T, typename Policy>
-    requires std::same_as<rng::range_value_t<T>, std::byte> &&
-             std::constructible_from<T, const std::byte*, const std::byte*> &&
+template <typename T, basic_bvalue_instantiation U, typename Policy = typename std::remove_cvref_t<U>::policy_type>
+    requires std::same_as<std::remove_cv_t<rng::range_value_t<T>>, std::byte> &&
+             std::constructible_from<T, rng::range_value_t<T>*, rng::range_value_t<T>*> &&
              rng::contiguous_range<policy_string_t<Policy>>
 constexpr nonstd::expected<T, conversion_errc> convert_from_bvalue_string_impl(
         customization_point_type<T>,
-        const basic_bvalue<Policy>& b,
+        U&& b,
         priority_tag<0>) noexcept
 {
     if (!holds_string(b)) [[unlikely]]
         return nonstd::make_unexpected(conversion_errc::not_string_type);
 
-    const auto& bstring = get_string(b);
-    try { return T(reinterpret_cast<const std::byte*>(rng::data(bstring)),
-                   reinterpret_cast<const std::byte*>(rng::data(bstring)+rng::size(bstring))); }
+    auto& bstring = get_string(b);
+    try { return T(reinterpret_cast<std::byte*>(rng::data(bstring)),
+                   reinterpret_cast<std::byte*>(rng::data(bstring)+rng::size(bstring))); }
     catch (...) { return nonstd::make_unexpected(conversion_errc::construction_error); }
 }
 
@@ -167,7 +187,6 @@ constexpr nonstd::expected<T, conversion_errc> convert_from_bvalue_list_impl(
         std::apply(
             [&]<std::size_t... IS>(std::index_sequence<IS...>&&) constexpr {
                 using std::get;
-
                 ( (get<IS>(out) = get_as<std::tuple_element_t<IS, T>>(
                                             detail::forward_like<BV>(blist[IS]))) , ... );
             },
@@ -181,6 +200,27 @@ constexpr nonstd::expected<T, conversion_errc> convert_from_bvalue_list_impl(
     return out;
 }
 
+// conversion to std::span<const char> or std::span<const std::byte>
+
+template <typename Tp, basic_bvalue_instantiation BV, typename U = std::remove_cvref_t<BV>>
+    requires (std::same_as<Tp, const char> || std::same_as<Tp, const std::byte>)
+             && std::same_as<typename detail::policy_string_t<BV>::value_type, char>
+constexpr nonstd::expected<std::span<const Tp>, conversion_errc> convert_from_bvalue_list_impl(
+        customization_point_type<std::span<const Tp>>,
+        BV&& b,
+        priority_tag<0>) noexcept
+{
+    if (!holds_string(b)) [[unlikely]]
+        return nonstd::make_unexpected(conversion_errc::not_list_type);
+
+    const auto& s = get_string(b);
+    if constexpr (std::same_as<Tp, std::byte>) {
+        return std::span(reinterpret_cast<const std::byte*>(s.data()), s.size());
+    } else {
+        return std::span(s.data(), s.size());
+    }
+}
+
 // Dict conversion
 
 template <typename T, basic_bvalue_instantiation BV, typename Policy = typename std::remove_cvref_t<BV>::policy_type>

include/bencode/detail/bview/comparison.hpp

@@ -31,31 +31,52 @@ constexpr auto compare_equality_with_bview_integer_impl(
 }
 
 template <typename T>
-    requires std::equality_comparable_with<std::string_view, T>
+    requires std::equality_comparable_with<T, std::string_view>
 constexpr bool compare_equality_with_bview_string_impl(
         customization_point_type<T>,
         const bview& bview,
         const T& value,
         priority_tag<1>)
 {
     if (!holds_string(bview)) return false;
-    return (get_string(bview) == value);
+    return (std::string_view(get_string(bview)) == value);
 }
 
 template <typename T>
-constexpr bool compare_equality_with_bvalue_string_impl(
+    requires std::equality_comparable_with<rng::range_value_t<T>, string_bview::value_type>
+constexpr bool compare_equality_with_bview_string_impl(
         customization_point_type<T>,
-        const bview& bv,
+        const bview& bview,
         const T& value,
         priority_tag<0>)
 {
-    if (!holds_string(bv)) return false;
-    const auto& s = get_string(bv);
-    return std::lexicographical_compare(
+    if (!holds_string(bview)) return false;
+    const auto s = get_string(bview);
+    return std::equal(
             rng::begin(s), rng::end(s),
             rng::begin(value), rng::end(value));
 }
 
+
+/// Comparison for byte strings
+template <typename T>
+    requires std::same_as<std::remove_cv_t<rng::range_value_t<T>>, std::byte>
+constexpr bool compare_equality_with_bview_string_impl(
+        customization_point_type<T>,
+        const bview& bview,
+        const T& value,
+        priority_tag<0>)
+{
+    if (!holds_string(bview)) return false;
+    const auto& s = get_string(bview);
+    return std::equal(
+            rng::begin(s), rng::end(s),
+            rng::begin(value), rng::end(value),
+            [] (char lhs, std::byte rhs) {
+                return short(lhs) == to_integer<short>(rhs);
+            });
+}
+
 template <typename T>
 constexpr bool compare_equality_with_bview_list_impl(
         customization_point_type<T>,
@@ -116,12 +137,12 @@ constexpr std::weak_ordering compare_three_way_with_bview_string_impl(
         priority_tag<1>)
 {
     if (!holds_string(bview)) return (bview.type() <=> bencode_type::string);
-    return (get_string(bview) <=> value);
+    return (std::string_view(get_string(bview)) <=> value);
 }
 
 
 template <typename T>
-    requires std::three_way_comparable<rng::range_value_t<T>, string_bview::value_type>
+    requires std::three_way_comparable_with<rng::range_value_t<T>, string_bview::value_type>
 constexpr std::weak_ordering compare_three_way_with_bview_string_impl(
         customization_point_type<T>,
         const bview& b,
@@ -136,6 +157,25 @@ constexpr std::weak_ordering compare_three_way_with_bview_string_impl(
             rng::begin(value), rng::end(value));
 }
 
+template <typename T>
+    requires std::same_as<std::remove_cv_t<rng::range_value_t<T>>, std::byte>
+constexpr std::weak_ordering compare_three_way_with_bview_string_impl(
+        customization_point_type<T>,
+        const bview& b,
+        const T& value,
+        priority_tag<0>)
+{
+    if (!holds_string(b)) return (b.type() <=> bencode_type::string);
+    const auto& bstring = get_string(b);
+
+    return std::lexicographical_compare_three_way(
+            rng::begin(bstring), rng::end(bstring),
+            rng::begin(value), rng::end(value),
+            [] (char lhs, std::byte rhs) {
+                return short(lhs) <=> to_integer<short>(rhs);
+            });
+}
+
 
 
 template <typename T>
@@ -219,15 +259,15 @@ constexpr bool compare_equality_with_bview(const bview& bv, const T& value)
         }
         else if constexpr (bencode::serialization_traits<T>::type == bencode_type::string) {
             return compare_equality_with_bview_string_impl(
-                    customization_for<T>, bv,value, priority_tag<1>{});
+                    customization_for<T>, bv, value, priority_tag<2>{});
         }
         else if constexpr (bencode::serialization_traits<T>::type == bencode_type::list) {
             return compare_equality_with_bview_list_impl(
-                    customization_for<T>, bv,value, priority_tag<0>{});
+                    customization_for<T>, bv, value, priority_tag<0>{});
         }
         else if constexpr (bencode::serialization_traits<T>::type == bencode_type::dict) {
             return compare_equality_with_bview_dict_impl(
-                    customization_for<T>, bv,value, priority_tag<0>{});
+                    customization_for<T>, bv, value, priority_tag<0>{});
         }
         else {
             static_assert(detail::always_false<T>::value, "no serializer for T found, check includes!");

include/bencode/traits/all.hpp

@@ -13,6 +13,7 @@
 #include "string.hpp"
 #include "string_view.hpp"
 #include "stringstream.hpp"
+#include "span.hpp"
 #include "tuple.hpp"
 #include "unordered_map.hpp"
 #include "unordered_set.hpp"

include/bencode/traits/span.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <span>
+#include "bencode/detail/serialization_traits.hpp"
+
+namespace bencode {
+
+template <std::size_t Extent>
+struct serialization_traits<std::span<char, Extent>>   : serializes_to_string {};
+
+template <std::size_t Extent>
+struct serialization_traits<std::span<const char, Extent>>   : serializes_to_string {};
+
+template <std::size_t Extent>
+struct serialization_traits<std::span<std::byte, Extent>>   : serializes_to_string {};
+
+template <std::size_t Extent>
+struct serialization_traits<std::span<const std::byte, Extent>>   : serializes_to_string {};
+
+template <serializable T, std::size_t Extent>
+struct serialization_traits<std::span<T, Extent>>   : serializes_to_list {};
+
+template <serializable T, std::size_t Extent>
+struct serialization_traits<std::span<const T, Extent>>   : serializes_to_list {};
+
+}

tests/CMakeLists.txt

@@ -36,7 +36,9 @@ target_sources(bencode-tests
         test_bencode_type.cpp
         test_connect.cpp
         test_bpointer.cpp
+
         traits/memory.cpp
+        traits/span.cpp
 )
 
 target_link_libraries(bencode-tests PRIVATE