From 93e10f1cc40f31aa4fd10ed09a42cc9caa3bdd8c Mon Sep 17 00:00:00 2001 From: Lee Clagett Date: Thu, 9 Mar 2017 15:50:51 -0500 Subject: [PATCH] Simplified the implementation and features of span --- contrib/epee/include/hex.h | 27 +-- contrib/epee/include/span.h | 130 ++++++++++++++ contrib/epee/include/span_view.h | 174 ------------------- contrib/epee/src/hex.cpp | 10 +- src/cryptonote_basic/cryptonote_basic_impl.h | 29 +++- src/ringct/rctTypes.h | 5 +- tests/unit_tests/crypto.cpp | 2 +- 7 files changed, 169 insertions(+), 208 deletions(-) create mode 100644 contrib/epee/include/span.h delete mode 100644 contrib/epee/include/span_view.h diff --git a/contrib/epee/include/hex.h b/contrib/epee/include/hex.h index 99a86503a..f8d6be048 100644 --- a/contrib/epee/include/hex.h +++ b/contrib/epee/include/hex.h @@ -33,46 +33,33 @@ #include #include -#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 src); - - //! \return A std::string containing hex of `src`. - static std::string string(const view src) { - return string(view_cast(src)); - } + static std::string string(const span src); //! \return An array containing hex of `src`. template - static std::array - array(const std::array& src) noexcept(noexcept(view(src))) + static std::array array(const std::array& src) noexcept { std::array 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 src); + static void buffer(std::ostream& out, const span src); //! Append `< + src + >` as hex to `out`. - static void formatted(std::ostream& out, const view src); - - //! Append `< + src + >` as hex to `out`. - template - static void formatted_from_pod(std::ostream& out, const T& pod) - { - formatted(out, pod_cast(pod)); - } + static void formatted(std::ostream& out, const span src); private: //! Write `src` bytes as hex to `out`. `out` must be twice the length - static void buffer_unchecked(char* out, const view src) noexcept; + static void buffer_unchecked(char* out, const span src) noexcept; }; } diff --git a/contrib/epee/include/span.h b/contrib/epee/include/span.h new file mode 100644 index 000000000..ea4ba63dd --- /dev/null +++ b/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 +#include +#include + +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` + and `span`. 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` 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 + 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(), "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 + 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` from a STL compatible `src`. + template + constexpr span to_span(const T& src) + { + // compiler provides diagnostic if size() is not size_t. + return {src.data(), src.size()}; + } + + template + constexpr bool has_padding() noexcept + { + return !std::is_pod() || alignof(T) != 1; + } + + //! \return Cast data from `src` as `span`. + template + span to_byte_span(const span src) noexcept + { + static_assert(!has_padding(), "source type may have padding"); + return {reinterpret_cast(src.data()), src.size_bytes()}; + } + + //! \return `span` which represents the bytes at `&src`. + template + span as_byte_span(const T& src) noexcept + { + static_assert(!std::is_empty(), "empty types will not work -> sizeof == 1"); + static_assert(!has_padding(), "source type may have padding"); + return {reinterpret_cast(std::addressof(src)), sizeof(T)}; + } +} diff --git a/contrib/epee/include/span_view.h b/contrib/epee/include/span_view.h deleted file mode 100644 index 33c538d37..000000000 --- a/contrib/epee/include/span_view.h +++ /dev/null @@ -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 -#include -#include -#include - -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` and `span`. 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` will include the - NULL-terminator. - \note `view` is an alias for `span` 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 - 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::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 - static constexpr T* data(T (&src)[N]) noexcept { return src; } - - template - static constexpr auto - data(C& src) noexcept(noexcept(src.data())) -> decltype(src.data()) { - return src.data(); - } - - - template - static constexpr std::size_t size(T (&)[N]) noexcept { return N; } - - template - 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::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())), - typename S = decltype(get::size(std::declval())), - typename = typename std::enable_if< - // Do not allow proxy iterators, but allow valid cv conversions - std::is_pointer::value && std::is_convertible::value && - // Prevent underflow/overflow on size storage - std::is_same::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 - using view = span::type>; - - //! \return `src` aliased as a view of type `T`. - template - view view_cast(const span& src) noexcept - { - using normalized = typename std::remove_cv::type; - static_assert( - std::is_same::value || std::is_same::value, - "only valid aliasing allowed - char or unsigned char target types" - ); - - static_assert(std::is_integral::value, "only integral source types"); - return {reinterpret_cast::type *>(src.data()), src.size_bytes()}; - } - - //! \return `src` aliased as a span of type `T`. - template - span pod_cast(U&& src) noexcept - { - using normalized = typename std::remove_cv::type; - static_assert( - std::is_same::value || std::is_same::value, - "only valid aliasing allowed - char or unsigned char target types" - ); - - using decayed = typename std::decay::type; - static_assert(std::is_pod::value, "only POD types allowed for conversion"); - static_assert(alignof(decayed) == 1, "only types with 1 byte alignment allowed for conversion"); - return {reinterpret_cast(std::addressof(src)), sizeof(decayed)}; - } -} diff --git a/contrib/epee/src/hex.cpp b/contrib/epee/src/hex.cpp index 6a698b5a9..cfbd3cf87 100644 --- a/contrib/epee/src/hex.cpp +++ b/contrib/epee/src/hex.cpp @@ -38,7 +38,7 @@ namespace epee namespace { template - void write_hex(T&& out, const view src) + void write_hex(T&& out, const span 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 src) + std::string to_hex::string(const span src) { if (std::numeric_limits::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 src) + void to_hex::buffer(std::ostream& out, const span src) { write_hex(std::ostreambuf_iterator{out}, src); } - void to_hex::formatted(std::ostream& out, const view src) + void to_hex::formatted(std::ostream& out, const span src) { out.put('<'); buffer(out, src); out.put('>'); } - void to_hex::buffer_unchecked(char* out, const view src) noexcept + void to_hex::buffer_unchecked(char* out, const span src) noexcept { return write_hex(out, src); } diff --git a/src/cryptonote_basic/cryptonote_basic_impl.h b/src/cryptonote_basic/cryptonote_basic_impl.h index 186ad85a0..14c03ac4c 100644 --- a/src/cryptonote_basic/cryptonote_basic_impl.h +++ b/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::secret_key &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_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::signature &v) { epee::to_hex::formatted_from_pod(o, 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::public_key &v) { + epee::to_hex::formatted(o, epee::as_byte_span(v)); return o; + } + inline std::ostream &operator <<(std::ostream &o, const crypto::secret_key &v) { + 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(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; + } } diff --git a/src/ringct/rctTypes.h b/src/ringct/rctTypes.h index baa99bbcb..c820fb297 100644 --- a/src/ringct/rctTypes.h +++ b/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); diff --git a/tests/unit_tests/crypto.cpp b/tests/unit_tests/crypto.cpp index 9febb7709..3a8e787ec 100644 --- a/tests/unit_tests/crypto.cpp +++ b/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. //