forked from such-gitea/wownero-lws
Update ::wire:: to be closer to Monero variant (#70)
This commit is contained in:
Lee *!* Clagett
committed by
Lee *!* Clagett
Lee *!* Clagett
parent
3e0555e07d
commit
e1bd9541f1
206
src/wire/write.h
206
src/wire/write.h
@@ -29,11 +29,16 @@
|
||||
|
||||
#include <array>
|
||||
#include <boost/utility/string_ref.hpp>
|
||||
#include <boost/range/size.hpp>
|
||||
#include <boost/range/adaptor/transformed.hpp>
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
#include <system_error>
|
||||
|
||||
#include "byte_slice.h" // monero/contrib/epee/include
|
||||
#include "byte_stream.h"// monero/contrib/epee/include
|
||||
#include "span.h" // monero/contrib/epee/include
|
||||
#include "wire/error.h"
|
||||
#include "wire/field.h"
|
||||
#include "wire/filters.h"
|
||||
#include "wire/traits.h"
|
||||
@@ -47,6 +52,9 @@ namespace wire
|
||||
|
||||
virtual ~writer() noexcept;
|
||||
|
||||
//! By default, insist on retrieving array size before writing array
|
||||
static constexpr std::true_type need_array_size() noexcept { return{}; }
|
||||
|
||||
virtual void boolean(bool) = 0;
|
||||
|
||||
virtual void integer(int) = 0;
|
||||
@@ -78,59 +86,62 @@ namespace wire
|
||||
writer& operator=(writer&&) = default;
|
||||
};
|
||||
|
||||
// leave in header, compiler can de-virtualize when final type is given
|
||||
template<typename W>
|
||||
inline void write_bytes(W& dest, const bool source)
|
||||
{ dest.boolean(source); }
|
||||
|
||||
inline void write_bytes(writer& dest, const bool source)
|
||||
{
|
||||
dest.boolean(source);
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const int source)
|
||||
{ dest.integer(source); }
|
||||
|
||||
inline void write_bytes(writer& dest, const int source)
|
||||
{
|
||||
dest.integer(source);
|
||||
}
|
||||
inline void write_bytes(writer& dest, const long source)
|
||||
{
|
||||
dest.integer(std::intmax_t(source));
|
||||
}
|
||||
inline void write_bytes(writer& dest, const long long source)
|
||||
{
|
||||
dest.integer(std::intmax_t(source));
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const long source)
|
||||
{ dest.integer(std::intmax_t(source)); }
|
||||
|
||||
inline void write_bytes(writer& dest, const unsigned source)
|
||||
{
|
||||
dest.unsigned_integer(source);
|
||||
}
|
||||
inline void write_bytes(writer& dest, const unsigned long source)
|
||||
{
|
||||
dest.unsigned_integer(std::uintmax_t(source));
|
||||
}
|
||||
inline void write_bytes(writer& dest, const unsigned long long source)
|
||||
{
|
||||
dest.unsigned_integer(std::uintmax_t(source));
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const long long source)
|
||||
{ dest.integer(std::intmax_t(source)); }
|
||||
|
||||
inline void write_bytes(writer& dest, const double source)
|
||||
{
|
||||
dest.real(source);
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const unsigned source)
|
||||
{ dest.unsigned_integer(source); }
|
||||
|
||||
inline void write_bytes(writer& dest, const boost::string_ref source)
|
||||
{
|
||||
dest.string(source);
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const unsigned long source)
|
||||
{ dest.unsigned_integer(std::uintmax_t(source)); }
|
||||
|
||||
template<typename T>
|
||||
inline enable_if<is_blob<T>::value> write_bytes(writer& dest, const T& source)
|
||||
{
|
||||
dest.binary(epee::as_byte_span(source));
|
||||
}
|
||||
template<typename W>
|
||||
inline void write_arithmetic(W& dest, const unsigned long long source)
|
||||
{ dest.unsigned_integer(std::uintmax_t(source)); }
|
||||
|
||||
inline void write_bytes(writer& dest, const epee::span<const std::uint8_t> source)
|
||||
{
|
||||
dest.binary(source);
|
||||
}
|
||||
template<typename W, typename T>
|
||||
inline std::enable_if_t<std::is_arithmetic<T>::value> write_bytes(W& dest, const T source)
|
||||
{ write_arithmetic(dest, source); }
|
||||
|
||||
template<typename W>
|
||||
inline void write_bytes(W& dest, const double source)
|
||||
{ dest.real(source); }
|
||||
|
||||
template<typename W>
|
||||
inline void write_bytes(W& dest, const boost::string_ref source)
|
||||
{ dest.string(source); }
|
||||
|
||||
template<typename W, typename T>
|
||||
inline std::enable_if_t<is_blob<T>::value> write_bytes(W& dest, const T& source)
|
||||
{ dest.binary(epee::as_byte_span(source)); }
|
||||
|
||||
template<typename W>
|
||||
inline void write_bytes(W& dest, const epee::span<const std::uint8_t> source)
|
||||
{ dest.binary(source); }
|
||||
|
||||
template<typename W>
|
||||
inline void write_bytes(W& dest, const epee::byte_slice& source)
|
||||
{ write_bytes(dest, epee::to_span(source)); }
|
||||
|
||||
//! Use `write_bytes(...)` method if available for `T`.
|
||||
template<typename W, typename T>
|
||||
inline auto write_bytes(W& dest, const T& source) -> decltype(source.write_bytes(dest))
|
||||
{ return source.write_bytes(dest); }
|
||||
}
|
||||
|
||||
namespace wire_write
|
||||
@@ -142,39 +153,80 @@ namespace wire_write
|
||||
declared after these functions. */
|
||||
|
||||
template<typename W, typename T>
|
||||
inline epee::byte_slice to_bytes(W&& dest, const T& value)
|
||||
inline void bytes(W& dest, const T& source)
|
||||
{
|
||||
write_bytes(dest, value);
|
||||
return dest.take_bytes();
|
||||
write_bytes(dest, source); // ADL (searches every associated namespace)
|
||||
}
|
||||
|
||||
template<typename W, typename T, typename U>
|
||||
inline std::error_code to_bytes(T& dest, const U& source)
|
||||
{
|
||||
try
|
||||
{
|
||||
W out{std::move(dest)};
|
||||
bytes(out, source);
|
||||
dest = out.take_sink();
|
||||
}
|
||||
catch (const wire::exception& e)
|
||||
{
|
||||
dest.clear();
|
||||
return e.code();
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
dest.clear();
|
||||
throw;
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
template<typename W, typename T>
|
||||
inline epee::byte_slice to_bytes(const T& value)
|
||||
inline std::error_code to_bytes(epee::byte_slice& dest, const T& source)
|
||||
{
|
||||
return wire_write::to_bytes(W{}, value);
|
||||
epee::byte_stream sink{};
|
||||
const std::error_code error = wire_write::to_bytes<W>(sink, source);
|
||||
if (error)
|
||||
{
|
||||
dest = nullptr;
|
||||
return error;
|
||||
}
|
||||
dest = epee::byte_slice{std::move(sink)};
|
||||
return {};
|
||||
}
|
||||
|
||||
template<typename W, typename T, typename F = wire::identity_>
|
||||
inline void array(W& dest, const T& source, const std::size_t count, F filter = F{})
|
||||
template<typename T>
|
||||
inline std::size_t array_size_(std::true_type, const T& source)
|
||||
{ return boost::size(source); }
|
||||
|
||||
template<typename T>
|
||||
inline constexpr std::size_t array_size_(std::false_type, const T&) noexcept
|
||||
{ return 0; }
|
||||
|
||||
template<typename W, typename T>
|
||||
inline constexpr std::size_t array_size(const W& dest, const T& source) noexcept
|
||||
{ return array_size_(dest.need_array_size(), source); }
|
||||
|
||||
template<typename W, typename T>
|
||||
inline void array(W& dest, const T& source)
|
||||
{
|
||||
using value_type = typename T::value_type;
|
||||
static_assert(!std::is_same<value_type, char>::value, "write array of chars as binary");
|
||||
static_assert(!std::is_same<value_type, std::uint8_t>::value, "write array of unsigned chars as binary");
|
||||
|
||||
dest.start_array(count);
|
||||
dest.start_array(array_size(dest, source));
|
||||
for (const auto& elem : source)
|
||||
write_bytes(dest, filter(elem));
|
||||
bytes(dest, elem);
|
||||
dest.end_array();
|
||||
}
|
||||
|
||||
template<typename W, typename T, unsigned I>
|
||||
inline bool field(W& dest, const wire::field_<T, true, I> elem)
|
||||
{
|
||||
// Arrays always optional, see `wire/field.h`
|
||||
// Arrays always optional, see `wire::field.h`
|
||||
if (wire::available(elem))
|
||||
{
|
||||
dest.key(I, elem.name);
|
||||
write_bytes(dest, elem.get_value());
|
||||
bytes(dest, elem.get_value());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -185,7 +237,7 @@ namespace wire_write
|
||||
if (wire::available(elem))
|
||||
{
|
||||
dest.key(I, elem.name);
|
||||
write_bytes(dest, *elem.get_value());
|
||||
bytes(dest, *elem.get_value());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@@ -199,13 +251,13 @@ namespace wire_write
|
||||
}
|
||||
|
||||
template<typename W, typename T, typename F, typename G>
|
||||
inline void dynamic_object(W& dest, const T& values, const std::size_t count, F key_filter, G value_filter)
|
||||
inline void dynamic_object(W& dest, const T& values, F key_filter, G value_filter)
|
||||
{
|
||||
dest.start_object(count);
|
||||
dest.start_object(array_size(dest, values));
|
||||
for (const auto& elem : values)
|
||||
{
|
||||
dest.key(key_filter(elem.first));
|
||||
write_bytes(dest, value_filter(elem.second));
|
||||
bytes(dest, value_filter(elem.second));
|
||||
}
|
||||
dest.end_object();
|
||||
}
|
||||
@@ -213,35 +265,31 @@ namespace wire_write
|
||||
|
||||
namespace wire
|
||||
{
|
||||
template<typename T, typename F = identity_>
|
||||
inline void array(writer& dest, const T& source, F filter = F{})
|
||||
template<typename W, typename T, typename F>
|
||||
inline void write_bytes(W& dest, const as_array_<T, F> source)
|
||||
{
|
||||
wire_write::array(dest, source, source.size(), std::move(filter));
|
||||
wire_write::array(dest, boost::adaptors::transform(source.get_value(), source.filter));
|
||||
}
|
||||
template<typename T, typename F>
|
||||
inline void write_bytes(writer& dest, as_array_<T, F> source)
|
||||
template<typename W, typename T>
|
||||
inline std::enable_if_t<is_array<T>::value> write_bytes(W& dest, const T& source)
|
||||
{
|
||||
wire::array(dest, source.get_value(), std::move(source.filter));
|
||||
}
|
||||
template<typename T>
|
||||
inline enable_if<is_array<T>::value> write_bytes(writer& dest, const T& source)
|
||||
{
|
||||
wire::array(dest, source);
|
||||
wire_write::array(dest, source);
|
||||
}
|
||||
|
||||
template<typename T, typename F = identity_, typename G = identity_>
|
||||
inline void dynamic_object(writer& dest, const T& source, F key_filter = F{}, G value_filter = G{})
|
||||
template<typename W, typename T, typename F = identity_, typename G = identity_>
|
||||
inline std::enable_if_t<std::is_base_of<writer, W>::value>
|
||||
dynamic_object(W& dest, const T& source, F key_filter = F{}, G value_filter = G{})
|
||||
{
|
||||
wire_write::dynamic_object(dest, source, source.size(), std::move(key_filter), std::move(value_filter));
|
||||
wire_write::dynamic_object(dest, source, std::move(key_filter), std::move(value_filter));
|
||||
}
|
||||
template<typename T, typename F, typename G>
|
||||
inline void write_bytes(writer& dest, as_object_<T, F, G> source)
|
||||
template<typename W, typename T, typename F, typename G>
|
||||
inline void write_bytes(W& dest, as_object_<T, F, G> source)
|
||||
{
|
||||
wire::dynamic_object(dest, source.get_map(), std::move(source.key_filter), std::move(source.value_filter));
|
||||
}
|
||||
|
||||
template<typename... T>
|
||||
inline void object(writer& dest, T... fields)
|
||||
template<typename W, typename... T>
|
||||
inline std::enable_if_t<std::is_base_of<writer, W>::value> object(W& dest, T... fields)
|
||||
{
|
||||
wire_write::object(dest, std::move(fields)...);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user