Simplified the implementation and features of span

contrib/epee/include/hex.h

@@ -33,46 +33,33 @@
 #include <iosfwd>
 #include <string>
 
-#include "span_view.h"
+#include "span.h"
 
 namespace epee
 {
   struct to_hex
   {
     //! \return A std::string containing hex of `src`.
-    static std::string string(const view<std::uint8_t> src);
+    static std::string string(const span<const std::uint8_t> src);
-
-    //! \return A std::string containing hex of `src`.
-    static std::string string(const view<char> src) {
-      return string(view_cast<std::uint8_t>(src));
-    }
 
     //! \return An array containing hex of `src`.
     template<std::size_t N>
-    static std::array<char, N * 2>
+    static std::array<char, N * 2> array(const std::array<std::uint8_t, N>& src) noexcept
-    array(const std::array<std::uint8_t, N>& src) noexcept(noexcept(view<std::uint8_t>(src)))
     {
       std::array<char, N * 2> out{{}};
       static_assert(N <= 128, "keep the stack size down");
-      buffer_unchecked(out.data(), src);
+      buffer_unchecked(out.data(), {src.data(), src.size()});
       return out;
     }
 
     //! Append `src` as hex to `out`.
-    static void buffer(std::ostream& out, const view<std::uint8_t> src);
+    static void buffer(std::ostream& out, const span<const std::uint8_t> src);
 
     //! Append `< + src + >` as hex to `out`.
-    static void formatted(std::ostream& out, const view<std::uint8_t> src);
+    static void formatted(std::ostream& out, const span<const std::uint8_t> src);
-
-    //! Append `< + src + >` as hex to `out`.
-    template<typename T>
-    static void formatted_from_pod(std::ostream& out, const T& pod)
-    {
-      formatted(out, pod_cast<const std::uint8_t>(pod));
-    }
 
   private:
     //! Write `src` bytes as hex to `out`. `out` must be twice the length
-    static void buffer_unchecked(char* out, const view<std::uint8_t> src) noexcept;
+    static void buffer_unchecked(char* out, const span<const std::uint8_t> src) noexcept;
   };
 }

contrib/epee/include/span.h

@@ -0,0 +1,130 @@
+// Copyright (c) 2017, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+namespace epee
+{
+  /*!
+    \brief Non-owning sequence of data. Does not deep copy
+
+    Inspired by `gsl::span` and/or `boost::iterator_range`. This class is
+    intended to be used as a parameter type for functions that need to take a
+    writable or read-only sequence of data. Most common cases are `span<char>`
+    and `span<std::uint8_t>`. Using as a class member is only recommended if
+    clearly documented as not doing a deep-copy. C-arrays are easily convertible
+    to this type.
+
+    \note Conversion from C string literal to `span<const char>` will include
+      the NULL-terminator.
+    \note Never allows derived-to-base pointer conversion; an array of derived
+      types is not an array of base types.
+   */
+  template<typename T>
+  class span
+  {
+    /* Supporting class types is tricky - the {ptr,len} constructor will allow
+       derived-to-base conversions. This is NOT desireable because an array of
+       derived types is not an array of base types. It is possible to handle
+       this case, implement when/if needed. */
+    static_assert(!std::is_class<T>(), "no class types are currently allowed");
+  public:
+    using value_type = T;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+
+    constexpr span() noexcept : ptr(nullptr), len(0) {}
+    constexpr span(std::nullptr_t) noexcept : span() {}
+
+    constexpr span(T* const src_ptr, const std::size_t count) noexcept
+      : ptr(src_ptr), len(count) {}
+
+    //! Conversion from C-array. Prevents common bugs with sizeof + arrays.
+    template<std::size_t N>
+    constexpr span(T (&src)[N]) noexcept : span(src, N) {}
+
+    constexpr span(const span&) noexcept = default;
+    span& operator=(const span&) noexcept = default;
+
+    constexpr iterator begin() const noexcept { return ptr; }
+    constexpr const_iterator cbegin() const noexcept { return ptr; }
+
+    constexpr iterator end() const noexcept { return begin() + size(); }
+    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
+
+    constexpr bool empty() const noexcept { return size() == 0; }
+    constexpr pointer data() const noexcept { return ptr; }
+    constexpr std::size_t size() const noexcept { return len; }
+    constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
+
+  private:
+    T* ptr;
+    std::size_t len;
+  };
+
+  //! \return `span<const T::value_type>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<const typename T::value_type> to_span(const T& src)
+  {
+    // compiler provides diagnostic if size() is not size_t.
+    return {src.data(), src.size()};
+  }
+
+  template<typename T>
+  constexpr bool has_padding() noexcept
+  {
+    return !std::is_pod<T>() || alignof(T) != 1;
+  }
+
+  //! \return Cast data from `src` as `span<const std::uint8_t>`.
+  template<typename T>
+  span<const std::uint8_t> to_byte_span(const span<const T> src) noexcept
+  {
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()}; 
+  }
+
+  //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
+  template<typename T>
+  span<const std::uint8_t> as_byte_span(const T& src) noexcept
+  {
+    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
+  }
+}

contrib/epee/include/span_view.h

@@ -1,174 +0,0 @@
-// Copyright (c) 2017, The Monero Project
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without modification, are
-// permitted provided that the following conditions are met:
-//
-// 1. Redistributions of source code must retain the above copyright notice, this list of
-//    conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list
-//    of conditions and the following disclaimer in the documentation and/or other
-//    materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its contributors may be
-//    used to endorse or promote products derived from this software without specific
-//    prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
-// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
-// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-#pragma once
-
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace epee
-{
-  /*!
-    \brief Non-owning sequence of data. Does not deep copy
-
-    Inspired by `gsl::span`. This class is intended to be used as a parameter
-    type for functions that need to take a writable or read-only sequence of
-    data. Most common cases are `span<char>` and `span<std::uint8_t>`. Using as
-    a class member is only recommended if clearly documented as not doing a
-    deep-copy. `std::vector`, `std::string`, `std::array`, and C-arrays are all
-    easily convertible to this type.
-
-    \note Conversion from C string literal to `view<char>` will include the
-      NULL-terminator.
-    \note `view<T>` is an alias for `span<const T>` which is read-only.
-    \note Never allows derived-to-base pointer conversion; an array of derived
-      types is not an array of base types.
-   */
-  template<typename T>
-  class span
-  {
-    /* Supporting class types is tricky - the {ptr,len} and {container}
-       constructors will allow derived-to-base conversions. This is NOT
-       desireable because an array of derived types is not an array of base
-       types. It is possible to handle this case, implement when/if needed. */
-    static_assert(std::is_integral<T>::value, "only integral values currently for span");
-
-    // Disables ADL for these calls.
-    struct get {
-      // we only accept pointer and size_t return types, so use noexcept aggressively
-      template<std::size_t N>
-      static constexpr T* data(T (&src)[N]) noexcept { return src; }
-
-      template<typename C>
-      static constexpr auto
-      data(C& src) noexcept(noexcept(src.data())) -> decltype(src.data()) {
-        return src.data();
-      }
-
-
-      template<std::size_t N>
-      static constexpr std::size_t size(T (&)[N]) noexcept { return N; }
-
-      template<typename C>
-      static constexpr auto
-      size(const C& src) noexcept(noexcept(src.size())) -> decltype(src.size()) {
-        return src.size();
-      }
-    };
-
-  public:
-    using value_type = T;
-    using pointer = T*;
-    using reference = T&;
-    using iterator = pointer;
-    using const_iterator = typename std::add_const<value_type>::type *;
-
-    constexpr span() noexcept : ptr(nullptr), len(0) {}
-    constexpr span(std::nullptr_t) noexcept : span() {}
-
-    constexpr span(T* const src_ptr, const std::size_t src_len) noexcept
-      : ptr(src_ptr), len(src_len) {
-    }
-
-    /*!
-       A `span` is implicitly convertible from any type where `get::data(src)`
-       returns a pointer convertible to T* and `get::size(src)` returns a
-       `std::size_t`. This constructor is disabled for all other types.
-     */
-    template<
-      typename C,
-      typename U = decltype(get::data(std::declval<C&>())),
-      typename S = decltype(get::size(std::declval<C&>())),
-      typename = typename std::enable_if<
-        // Do not allow proxy iterators, but allow valid cv conversions
-        std::is_pointer<U>::value && std::is_convertible<U, pointer>::value &&
-        // Prevent underflow/overflow on size storage
-        std::is_same<S, std::size_t>::value
-      >::type
-    >
-    constexpr span(C&& src) noexcept(noexcept(get::data(src), get::size(src)))
-      : span(get::data(src), get::size(src)) {
-    }
-
-    constexpr span(span&&) noexcept = default;
-    constexpr span(span&) noexcept = default;
-    constexpr span(const span&) noexcept = default;
-    span& operator=(const span&) noexcept = default;
-
-    constexpr iterator begin() const noexcept { return ptr; }
-    constexpr const_iterator cbegin() const noexcept { return ptr; }
-
-    constexpr iterator end() const noexcept { return begin() + size(); }
-    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
-
-    constexpr bool empty() const noexcept { return size() == 0; }
-    constexpr pointer data() const noexcept { return ptr; }
-    constexpr std::size_t size() const noexcept { return len; }
-    constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
-
-  private:
-    T* ptr;
-    std::size_t len;
-  };
-
-  //! A `view` is a `span` over immutable data. See `span` for more info.
-  template<typename T>
-  using view = span<typename std::add_const<T>::type>;
-
-  //! \return `src` aliased as a view of type `T`.
-  template<typename T, typename U>
-  view<T> view_cast(const span<U>& src) noexcept
-  {
-    using normalized = typename std::remove_cv<T>::type;
-    static_assert(
-      std::is_same<normalized, char>::value || std::is_same<normalized, std::uint8_t>::value,
-      "only valid aliasing allowed - char or unsigned char target types"
-    );
-
-    static_assert(std::is_integral<U>::value, "only integral source types");
-    return {reinterpret_cast<typename std::add_const<T>::type *>(src.data()), src.size_bytes()};
-  }
-
-  //! \return `src` aliased as a span of type `T`.
-  template<typename T, typename U>
-  span<T> pod_cast(U&& src) noexcept
-  {
-    using normalized = typename std::remove_cv<T>::type;
-    static_assert(
-      std::is_same<normalized, char>::value || std::is_same<normalized, std::uint8_t>::value,
-      "only valid aliasing allowed - char or unsigned char target types"
-    );
-
-    using decayed = typename std::decay<U>::type;
-    static_assert(std::is_pod<decayed>::value, "only POD types allowed for conversion");
-    static_assert(alignof(decayed) == 1, "only types with 1 byte alignment allowed for conversion");
-    return {reinterpret_cast<T*>(std::addressof(src)), sizeof(decayed)};
-  }
-}

contrib/epee/src/hex.cpp

@@ -38,7 +38,7 @@ namespace epee
   namespace
   {
     template<typename T>
-    void write_hex(T&& out, const view<std::uint8_t> src)
+    void write_hex(T&& out, const span<const std::uint8_t> src)
     {
       static constexpr const char hex[] = u8"0123456789abcdef";
       static_assert(sizeof(hex) == 17, "bad string size");
@@ -52,7 +52,7 @@ namespace epee
     }
   }
 
-  std::string to_hex::string(const view<std::uint8_t> src)
+  std::string to_hex::string(const span<const std::uint8_t> src)
   {
     if (std::numeric_limits<std::size_t>::max() / 2 < src.size())
       throw std::range_error("hex_view::to_string exceeded maximum size");
@@ -63,19 +63,19 @@ namespace epee
     return out;
   }
 
-  void to_hex::buffer(std::ostream& out, const view<std::uint8_t> src)
+  void to_hex::buffer(std::ostream& out, const span<const std::uint8_t> src)
   {
     write_hex(std::ostreambuf_iterator<char>{out}, src);
   }
 
-  void to_hex::formatted(std::ostream& out, const view<std::uint8_t> src)
+  void to_hex::formatted(std::ostream& out, const span<const std::uint8_t> src)
   {
     out.put('<');
     buffer(out, src);
     out.put('>');
   }
 
-  void to_hex::buffer_unchecked(char* out, const view<std::uint8_t> src) noexcept
+  void to_hex::buffer_unchecked(char* out, const span<const std::uint8_t> src) noexcept
   {
     return write_hex(out, src);
   }

src/cryptonote_basic/cryptonote_basic_impl.h

@@ -34,6 +34,7 @@
 #include "crypto/crypto.h"
 #include "crypto/hash.h"
 #include "hex.h"
+#include "span.h"
 
 
 namespace cryptonote {
@@ -127,11 +128,25 @@ namespace cryptonote {
 bool parse_hash256(const std::string str_hash, crypto::hash& hash);
 
 namespace crypto {
-  inline std::ostream &operator <<(std::ostream &o, const crypto::public_key &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::public_key &v) {
-  inline std::ostream &operator <<(std::ostream &o, const crypto::secret_key &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
-  inline std::ostream &operator <<(std::ostream &o, const crypto::key_derivation &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+  }
-  inline std::ostream &operator <<(std::ostream &o, const crypto::key_image &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::secret_key &v) {
-  inline std::ostream &operator <<(std::ostream &o, const crypto::signature &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
-  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+  }
-  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::key_derivation &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+  }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::key_image &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+  }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::signature &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+  }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::hash &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+  }
+  inline std::ostream &operator <<(std::ostream &o, const crypto::hash8 &v) {
+    epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+  }
 }

src/ringct/rctTypes.h

@@ -48,6 +48,7 @@ extern "C" {
 #include "crypto/crypto.h"
 
 #include "hex.h"
+#include "span.h"
 #include "serialization/serialization.h"
 #include "serialization/debug_archive.h"
 #include "serialization/binary_archive.h"
@@ -444,7 +445,9 @@ namespace cryptonote {
     static inline bool operator!=(const crypto::secret_key &k0, const rct::key &k1) { return memcmp(&k0, &k1, 32); }
 }
 
-inline std::ostream &operator <<(std::ostream &o, const rct::key &v) { epee::to_hex::formatted_from_pod(o, v); return o; }
+inline std::ostream &operator <<(std::ostream &o, const rct::key &v) {
+  epee::to_hex::formatted(o, epee::as_byte_span(v)); return o;
+}
 
 
 BLOB_SERIALIZER(rct::key);

tests/unit_tests/crypto.cpp

@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2017, The Monero Project
+// Copyright (c) 2017, The Monero Project
 //
 // All rights reserved.
 //