Improvements for epee binary to hex functions:

  - Performance improvements
  - Added `span` for zero-copy pointer+length arguments
  - Added `std::ostream` overload for direct writing to output buffers
  - Removal of unused `string_tools::buff_to_hex`

6 files changed, 342 insertions, 49 deletions

diff --git a/contrib/epee/include/hex.h b/contrib/epee/include/hex.h
new file mode 100644
index 000000000..99a86503a
--- /dev/null
+++ b/contrib/epee/include/hex.h
@@ -0,0 +1,78 @@
+// 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 <array>
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+
+#include "span_view.h"
+
+namespace epee
+{
+  struct to_hex
+  {
+    //! \return A std::string containing hex of `src`.
+    static std::string string(const view<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>
+    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);
+      return out;
+    }
+
+    //! Append `src` as hex to `out`.
+    static void buffer(std::ostream& out, const view<std::uint8_t> src);
+
+    //! Append `< + src + >` as hex to `out`.
+    static void formatted(std::ostream& out, const view<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;
+  };
+}
diff --git a/contrib/epee/include/span_view.h b/contrib/epee/include/span_view.h
new file mode 100644
index 000000000..33c538d37
--- /dev/null
+++ b/contrib/epee/include/span_view.h
@@ -0,0 +1,174 @@
+// 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)};
+  }
+}
diff --git a/contrib/epee/include/string_tools.h b/contrib/epee/include/string_tools.h
index 530000028..67984b9e4 100644
--- a/contrib/epee/include/string_tools.h
+++ b/contrib/epee/include/string_tools.h
@@ -45,6 +45,8 @@
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
+#include "hex.h"
+#include "span.h"
 #include "warnings.h"
 
 
@@ -114,33 +116,10 @@ namespace string_tools
 			return false;
 		}
 	}
-	//----------------------------------------------------------------------------
-  template<class CharT>
-  std::basic_string<CharT> buff_to_hex(const std::basic_string<CharT>& s)
-  {
-    using namespace std;
-    basic_stringstream<CharT> hexStream;
-    hexStream << hex << noshowbase << setw(2);
-
-    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
-    {
-      hexStream << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(*it)) << " ";
-    }
-    return hexStream.str();
-  }
   //----------------------------------------------------------------------------
-  template<class CharT>
-  std::basic_string<CharT> buff_to_hex_nodelimer(const std::basic_string<CharT>& s)
+  inline std::string buff_to_hex_nodelimer(const std::string& src)
   {
-    using namespace std;
-    basic_stringstream<CharT> hexStream;
-    hexStream << hex << noshowbase;
-
-    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
-    {
-      hexStream << setw(2) << setfill('0') << static_cast<unsigned int>(static_cast<unsigned char>(*it));
-    }
-    return hexStream.str();
+    return to_hex::string(to_byte_span(to_span(src)));
   }
   //----------------------------------------------------------------------------
   template<class CharT>
@@ -559,9 +538,7 @@ POP_WARNINGS
   std::string pod_to_hex(const t_pod_type& s)
   {
     static_assert(std::is_pod<t_pod_type>::value, "expected pod type");
-    std::string buff;
-    buff.assign(reinterpret_cast<const char*>(&s), sizeof(s));
-    return buff_to_hex_nodelimer(buff);
+    return to_hex::string(as_byte_span(s));
   }
   //----------------------------------------------------------------------------
   template<class t_pod_type>
diff --git a/contrib/epee/src/CMakeLists.txt b/contrib/epee/src/CMakeLists.txt
index 9db4c46ce..1d5fa0394 100644
--- a/contrib/epee/src/CMakeLists.txt
+++ b/contrib/epee/src/CMakeLists.txt
@@ -26,7 +26,7 @@
 # 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.
 
-add_library(epee STATIC http_auth.cpp mlog.cpp string_tools.cpp)
+add_library(epee STATIC hex.cpp http_auth.cpp mlog.cpp string_tools.cpp)
 # Build and install libepee if we're building for GUI
 if (BUILD_GUI_DEPS)
     if(IOS)
diff --git a/contrib/epee/src/hex.cpp b/contrib/epee/src/hex.cpp
new file mode 100644
index 000000000..6a698b5a9
--- /dev/null
+++ b/contrib/epee/src/hex.cpp
@@ -0,0 +1,82 @@
+// 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.
+
+#include "hex.h"
+
+#include <iterator>
+#include <limits>
+#include <ostream>
+#include <stdexcept>
+
+namespace epee
+{
+  namespace
+  {
+    template<typename T>
+    void write_hex(T&& out, const view<std::uint8_t> src)
+    {
+      static constexpr const char hex[] = u8"0123456789abcdef";
+      static_assert(sizeof(hex) == 17, "bad string size");
+      for (const std::uint8_t byte : src)
+      {
+        *out = hex[byte >> 4];
+        ++out;
+        *out = hex[byte & 0x0F];
+        ++out;
+      }
+    }
+  }
+
+  std::string to_hex::string(const view<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");
+
+    std::string out{};
+    out.resize(src.size() * 2);
+    buffer_unchecked(std::addressof(out[0]), src);
+    return out;
+  }
+
+  void to_hex::buffer(std::ostream& out, const view<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)
+  {
+    out.put('<');
+    buffer(out, src);
+    out.put('>');
+  }
+
+  void to_hex::buffer_unchecked(char* out, const view<std::uint8_t> src) noexcept
+  {
+    return write_hex(out, src);
+  }
+}
diff --git a/contrib/epee/src/http_auth.cpp b/contrib/epee/src/http_auth.cpp
index 5a1c2142a..30e562700 100644
--- a/contrib/epee/src/http_auth.cpp
+++ b/contrib/epee/src/http_auth.cpp
@@ -67,6 +67,7 @@
 #include <type_traits>
 
 #include "crypto/crypto.h"
+#include "hex.h"
 #include "md5_l.h"
 #include "string_coding.h"
 
@@ -104,25 +105,6 @@ namespace
 
   //// Digest Algorithms
 
-  template<std::size_t N>
-  std::array<char, N * 2> to_hex(const std::array<std::uint8_t, N>& digest) noexcept
-  {
-    static constexpr const char alphabet[] = u8"0123456789abcdef";
-    static_assert(sizeof(alphabet) == 17, "bad alphabet size");
-
-    // TODO upgrade (improve performance) of to hex in epee string tools
-    std::array<char, N * 2> out{{}};
-    auto current = out.begin();
-    for (const std::uint8_t byte : digest)
-    {
-      *current = alphabet[byte >> 4];
-      ++current;
-      *current = alphabet[byte & 0x0F];
-      ++current;
-    }
-    return out;
-  }
-
   struct md5_
   {
     static constexpr const boost::string_ref name = ceref(u8"MD5");
@@ -156,7 +138,7 @@ namespace
 
       std::array<std::uint8_t, 16> digest{{}};
       md5::MD5Final(digest.data(), std::addressof(ctx));
-      return to_hex(digest);
+      return epee::to_hex::array(digest);
     }
   };
   constexpr const boost::string_ref md5_::name;