kumi/danicoin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Simplified the implementation and features of span

Browse source
This commit is contained in:
Lee Clagett 2017-03-09 15:50:51 -05:00
parent 4a8f96f95d
commit 93e10f1cc4
7 changed files with 169 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
contrib/epee/include/hex.h
View file

@ -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);
//! \return A std::string containing hex of `src`.
static std::string string(const view<char> src) {
return string(view_cast<std::uint8_t>(src));
}
static std::string string(const span<const 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)))
static std::array<char, N * 2> array(const std::array<std::uint8_t, N>& src) noexcept
{
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);
//! 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));
}
static void formatted(std::ostream& out, const span<const std::uint8_t> src);
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;
};
}

130
contrib/epee/include/span.h Normal file
View file

@ -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)};
}
}

174
contrib/epee/include/span_view.h
View file

@ -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)};
}
}

10
contrib/epee/src/hex.cpp
View file

@ -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);
}

29
src/cryptonote_basic/cryptonote_basic_impl.h
View file

@ -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;
}
}

5
src/ringct/rctTypes.h
View file

@ -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);

2
tests/unit_tests/crypto.cpp
View file

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