Rework how decoding is set up to support a wider variety of inputs

Author: jimporter

CHANGES.md

@@ -5,6 +5,7 @@
 ### New features
 - `bencode::data` (and `bencode::basic_data`, etc) now support `operator []` and
   `at` member functions to get list/dictionary elements
+- Decoding functions now accept a pointer plus length as input
 
 ### Breaking changes
 - To decode only the next bencode object in a string or stream, you must now

README.md

@@ -54,18 +54,20 @@ However, you can [customize this](#bringing-your-own-variant) if you like.
 
 ### Decoding
 
-Decoding bencoded data is simple. Just call `decode`, which will return a `data`
-object that you can operate on:
+Decoding bencoded data is simple. Just call `decode` with a string or some other
+container holding character data. This will return a `data` object that you can
+operate on:
 
 ```c++
 bencode::data data = bencode::decode("i42e");
 auto value = std::get<bencode::integer>(data);
 ```
 
-`decode` also has an overload that takes an iterator pair:
+`decode` also has overloads that takes an iterator pair or a pointer and length:
 
 ```c++
-auto data = bencode::decode(foo.begin(), foo.end());
+auto data1 = bencode::decode(foo.begin(), foo.end());
+auto data2 = bencode::decode(c_str, std::strlen(c_str));
 ```
 
 Finally, you can pass an `std::istream` directly to `decode`. By default, this
@@ -96,7 +98,9 @@ auto data2 = bencode::decode_some(input); // contains "foo"
 ```
 
 When calling `decode_some` with an iterator pair, it will update the value of
-the "begin" iterator in-place to point to where the parsing left off.
+the "begin" iterator in-place to point to where the parsing left off. Similary,
+calling `decode_some` with a pointer or pointer/length, it will update the
+pointer's value in-place.
 
 #### Views
 

include/bencode.hpp

@@ -335,6 +335,17 @@ namespace bencode {
     template<typename T>
     inline constexpr bool is_view_v = is_view<T>::value;
 
+    template<typename, typename = std::void_t<>>
+    struct is_iterable : std::false_type {};
+
+    template<typename T>
+    struct is_iterable<T, std::void_t<
+      decltype(std::begin(std::declval<T&>()), std::end(std::declval<T&>()))
+    >> : std::true_type {};
+
+    template<typename T>
+    inline constexpr bool is_iterable_v = is_iterable<T>::value;
+
     template<typename Integer>
     inline void check_overflow(Integer value, Integer digit) {
       using limits = std::numeric_limits<Integer>;
@@ -607,9 +618,21 @@ namespace bencode {
     return detail::do_decode<Data>(b, end, true);
   }
 
+  template<typename Data, typename String,
+           std::enable_if_t<detail::is_iterable_v<String> &&
+                            !std::is_array_v<String>, bool> = true>
+  inline Data basic_decode(const String &s) {
+    return basic_decode<Data>(std::begin(s), std::end(s));
+  }
+
+  template<typename Data>
+  inline Data basic_decode(const char *s) {
+    return basic_decode<Data>(s, s + std::strlen(s));
+  }
+
   template<typename Data>
-  inline Data basic_decode(const string_view &s) {
-    return basic_decode<Data>(s.begin(), s.end());
+  inline Data basic_decode(const char *s, std::size_t length) {
+    return basic_decode<Data>(s, s + length);
   }
 
   template<typename Data>
@@ -622,6 +645,16 @@ namespace bencode {
     return detail::do_decode<Data>(begin, end, false);
   }
 
+  template<typename Data>
+  inline Data basic_decode_some(const char *&s) {
+    return basic_decode_some<Data>(s, s + std::strlen(s));
+  }
+
+  template<typename Data>
+  inline Data basic_decode_some(const char *&s, std::size_t length) {
+    return basic_decode_some<Data>(s, s + length);
+  }
+
   template<typename Data>
   inline Data basic_decode_some(std::istream &s, eof_behavior e = check_eof) {
     return detail::do_decode<Data>(s, e, false);