@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/include/eosio/to_json.hpp

@@ -1,279 +0,0 @@
-#pragma once
-
-#include <cmath>
-#include "for_each_field.hpp"
-#include "fpconv.h"
-#include "stream.hpp"
-#include "types.hpp"
-#include <limits>
-#include <optional>
-#include <rapidjson/encodings.h>
-#include <variant>
-
-namespace eosio {
-
-inline constexpr char hex_digits[] = "0123456789ABCDEF";
-
-// Adaptors for rapidjson
-struct stream_adaptor {
-   stream_adaptor(const char* src, int sz) {
-      int chars = std::min(sz, 4);
-      memcpy(buf, src, chars);
-      memset(buf + chars, 0, 4 - chars);
-   }
-   void Put(char ch) {}
-   char Take() { return buf[idx++]; }
-   char buf[4];
-   int  idx = 0;
-};
-
-// Replaces any invalid utf-8 bytes with ?
-template <typename S>
-void to_json(std::string_view sv, S& stream) {
-   stream.write('"');
-   auto begin = sv.begin();
-   auto end   = sv.end();
-   while (begin != end) {
-      auto pos = begin;
-      while (pos != end && *pos != '"' && *pos != '\\' && (unsigned char)(*pos) >= 32 && *pos != 127) ++pos;
-      while (begin != pos) {
-         stream_adaptor s2(begin, static_cast<std::size_t>(pos - begin));
-         if (rapidjson::UTF8<>::Validate(s2, s2)) {
-            stream.write(begin, s2.idx);
-            begin += s2.idx;
-         } else {
-            ++begin;
-            stream.write('?');
-         }
-      }
-      if (begin != end) {
-         if (*begin == '"') {
-            stream.write("\\\"", 2);
-         } else if (*begin == '\\') {
-            stream.write("\\\\", 2);
-         } else {
-            stream.write("\\u00", 4);
-            stream.write(hex_digits[(unsigned char)(*begin) >> 4]);
-            stream.write(hex_digits[(unsigned char)(*begin) & 15]);
-         }
-         ++begin;
-      }
-   }
-   stream.write('"');
-}
-
-template <typename S>
-void to_json(const std::string& s, S& stream) {
-   to_json(std::string_view{ s }, stream);
-}
-
-template <typename S>
-void to_json(const char* s, S& stream) {
-   to_json(std::string_view{ s }, stream);
-}
-
-/*
-template <typename S>
-result<void> to_json(const shared_memory<std::string_view>& s, S& stream) {
-   return to_json(*s, stream);
-}
-*/
-
-template <typename S>
-void to_json(bool value, S& stream) {
-   if (value)
-      stream.write("true", 4);
-   else
-      stream.write("false", 5);
-}
-
-template <typename T, typename S>
-void int_to_json(T value, S& stream) {
-   auto                                               uvalue = std::make_unsigned_t<T>(value);
-   small_buffer<std::numeric_limits<T>::digits10 + 4> b;
-   bool                                               neg = value < 0;
-   if (neg)
-      uvalue = -uvalue;
-   if (sizeof(T) > 4)
-      *b.pos++ = '"';
-   do {
-      *b.pos++ = '0' + (uvalue % 10);
-      uvalue /= 10;
-   } while (uvalue);
-   if (neg)
-      *b.pos++ = '-';
-   if (sizeof(T) > 4)
-      *b.pos++ = '"';
-   b.reverse();
-   stream.write(b.data, b.pos - b.data);
-}
-
-template <typename S>
-void fp_to_json(double value, S& stream) {
-   // fpconv is not quite consistent with javascript for nans and infinities
-   if (value == std::numeric_limits<double>::infinity()) {
-      stream.write("\"Infinity\"", 10);
-   } else if (value == -std::numeric_limits<double>::infinity()) {
-      stream.write("\"-Infinity\"", 11);
-   } else if (std::isnan(value)) {
-      stream.write("\"NaN\"", 5);
-   } else {
-      small_buffer<24> b; // fpconv_dtoa generates at most 24 characters
-      int              n = fpconv_dtoa(value, b.pos);
-      check( n > 0, convert_stream_error(stream_error::float_error) );
-      b.pos += n;
-      stream.write(b.data, b.pos - b.data);
-   }
-}
-
-// clang-format off
-template <typename S> void to_json(unsigned char value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(uint16_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(uint32_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(uint64_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(char value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(signed char value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(int16_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(int32_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(int64_t value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(double value, S& stream) { return fp_to_json(value, stream); }
-template <typename S> void to_json(float value, S& stream) { return fp_to_json(value, stream); }
-
-#ifndef ABIEOS_NO_INT128
-template <typename S> void to_json(unsigned __int128 value, S& stream) { return int_to_json(value, stream); }
-template <typename S> void to_json(__int128 value, S& stream) { return int_to_json(value, stream); }
-#endif
-
-// clang-format on
-
-template <typename T, typename S>
-void to_json(const std::vector<T>& obj, S& stream) {
-   stream.write('[');
-   bool first = true;
-   for (auto& v : obj) {
-      if (first) {
-         increase_indent(stream);
-      } else {
-         stream.write(',');
-      }
-      write_newline(stream);
-      first = false;
-      to_json(v, stream);
-   }
-   if (!first) {
-      decrease_indent(stream);
-      write_newline(stream);
-   }
-   stream.write(']');
-}
-
-template <typename T, typename S>
-void to_json(const std::optional<T>& obj, S& stream) {
-   if (obj) {
-      to_json(*obj, stream);
-   } else {
-      stream.write("null", 4);
-   }
-}
-
-template <typename... T, typename S>
-void to_json(const std::variant<T...>& obj, S& stream) {
-   stream.write('[');
-   increase_indent(stream);
-   write_newline(stream);
-   std::visit(
-      [&](const auto& t) { to_json(get_type_name((std::decay_t<decltype(t)>*)nullptr), stream); }, obj);
-   stream.write(',');
-   write_newline(stream);
-   std::visit([&](auto& x) { return to_json(x, stream); }, obj);
-   decrease_indent(stream);
-   write_newline(stream);
-   stream.write(']');
-}
-
-   template<typename>
-   struct is_std_optional : std::false_type {};
-
-   template<typename T>
-   struct is_std_optional<std::optional<T>> : std::true_type {
-      using value_type = T;
-   };
-
-template <typename T, typename S>
-void to_json(const T& t, S& stream) {
-   bool         first = true;
-   stream.write('{');
-   eosio::for_each_field<T>([&](const char* name, auto&& member) {
-       auto addfield = [&]() {
-         if (first) {
-            increase_indent(stream);
-            first = false;
-         } else {
-            stream.write(',');
-         }
-         write_newline(stream);
-         to_json(name, stream);
-         write_colon(stream);
-         to_json(member(&t), stream);
-      };
-
-      auto m = member(&t);
-      using member_type = std::decay_t<decltype(m)>;
-      if constexpr ( not is_std_optional<member_type>::value ) {
-         addfield();
-      } else {
-         // !!! Skipping empty optionals breaks the tests, because
-         // abi serialization can't handle it.
-         if( !!m || true )
-            addfield();
-      }
-   });
-   if (!first) {
-      decrease_indent(stream);
-      write_newline(stream);
-   }
-   stream.write('}');
-}
-
-template <typename S>
-void to_json_hex(const char* data, size_t size, S& stream) {
-   stream.write('"');
-   for (size_t i = 0; i < size; ++i) {
-      unsigned char byte = data[i];
-      stream.write(hex_digits[byte >> 4]);
-      stream.write(hex_digits[byte & 15]);
-   }
-   stream.write('"');
-}
-
-#ifdef __eosio_cdt__
-
-template <typename S> void to_json(long double value, S& stream) {
-   return to_json_hex(reinterpret_cast<const char*>(&value), sizeof(long double), stream);
-}
-
-#endif
-
-template <typename T>
-std::string convert_to_json(const T& t) {
-   size_stream ss;
-   to_json(t, ss);
-   std::string      result(ss.size, 0);
-   fixed_buf_stream fbs(result.data(), result.size());
-   to_json(t, fbs);
-   check( fbs.pos == fbs.end, convert_stream_error(stream_error::underrun) );
-   return result;
-}
-
-template <typename T>
-std::string format_json(const T& t) {
-   pretty_stream<size_stream> ss;
-   to_json(t, ss);
-   std::string                     result(ss.size, 0);
-   pretty_stream<fixed_buf_stream> fbs(result.data(), result.size());
-   to_json(t, fbs);
-   check( fbs.pos == fbs.end, convert_stream_error(stream_error::underrun) );
-   return result;
-}
-
-} // namespace eosio

package/include/eosio/to_key.hpp

@@ -1,298 +0,0 @@
-#pragma once
-
-#include <deque>
-#include "for_each_field.hpp"
-#include "stream.hpp"
-#include <list>
-#include <map>
-#include <optional>
-#include <set>
-#include <tuple>
-#include <utility>
-#include <variant>
-#include <vector>
-#include <cstring>
-
-namespace eosio {
-
-template <typename... Ts, typename S>
-void to_key(const std::tuple<Ts...>& obj, S& stream);
-
-// to_key defines a conversion from a type to a sequence of bytes whose lexicograpical
-// ordering is the same as the ordering of the original type.
-//
-// For any two objects of type T, a and b:
-//
-// - key(a) < key(b) iff a < b
-// - key(a) is not a prefix of key(b)
-//
-// Overloads of to_key for user-defined types can be found by Koenig lookup.
-//
-// Abieos provides specializations of to_key for the following types
-// - std::string and std::string_view
-// - std::vector, std::list, std::deque
-// - std::tuple
-// - std::array
-// - std::optional
-// - std::variant
-// - Arithmetic types
-// - Scoped enumeration types
-// - Reflected structs
-// - All smart-contract related types defined by abieos
-template <typename T, typename S>
-void to_key(const T& obj, S& stream);
-
-template <int i, typename T, typename S>
-void to_key_tuple(const T& obj, S& stream) {
-   if constexpr (i < std::tuple_size_v<T>) {
-      to_key(std::get<i>(obj), stream);
-      to_key_tuple<i + 1>(obj, stream);
-   }
-}
-
-template <typename... Ts, typename S>
-void to_key(const std::tuple<Ts...>& obj, S& stream) {
-   to_key_tuple<0>(obj, stream);
-}
-
-template <typename T, std::size_t N, typename S>
-void to_key(const std::array<T, N>& obj, S& stream) {
-   for (const T& elem : obj) { to_key(elem, stream); }
-}
-
-template <typename T, typename S>
-void to_key_optional(const bool* obj, S& stream) {
-   if (obj == nullptr)
-      stream.write('\0');
-   else if (!*obj)
-      stream.write('\1');
-   else
-      stream.write('\2');
-}
-
-template <typename T, typename S>
-void to_key_optional(const T* obj, S& stream) {
-   if constexpr (has_bitwise_serialization<T>() && sizeof(T) == 1) {
-      if (obj == nullptr)
-         stream.write("\0", 2);
-      else {
-         char             buf[1];
-         fixed_buf_stream tmp_stream(buf, 1);
-         to_key(*obj, tmp_stream);
-         stream.write(buf[0]);
-         if (buf[0] == '\0')
-            stream.write('\1');
-      }
-   } else {
-      if (obj) {
-         stream.write('\1');
-         to_key(*obj, stream);
-      } else {
-         stream.write('\0');
-      }
-   }
-}
-
-template <typename T, typename U, typename S>
-void to_key(const std::pair<T, U>& obj, S& stream) {
-   to_key(obj.first, stream);
-   to_key(obj.second, stream);
-}
-
-template <typename T, typename S>
-void to_key_range(const T& obj, S& stream) {
-   for (const auto& elem : obj) { to_key_optional(&elem, stream); }
-   to_key_optional((decltype(&*std::begin(obj))) nullptr, stream);
-}
-
-template <typename T, typename S>
-void to_key(const std::vector<T>& obj, S& stream) {
-   for (const T& elem : obj) { to_key_optional(&elem, stream); }
-   to_key_optional((const T*)nullptr, stream);
-}
-
-template <typename T, typename S>
-void to_key(const std::list<T>& obj, S& stream) {
-   to_key_range(obj, stream);
-}
-
-template <typename T, typename S>
-void to_key(const std::deque<T>& obj, S& stream) {
-   to_key_range(obj, stream);
-}
-
-template <typename T, typename S>
-void to_key(const std::set<T>& obj, S& stream) {
-   to_key_range(obj, stream);
-}
-
-template <typename T, typename U, typename S>
-void to_key(const std::map<T, U>& obj, S& stream) {
-   to_key_range(obj, stream);
-}
-
-template <typename T, typename S>
-void to_key(const std::optional<T>& obj, S& stream) {
-   to_key_optional(obj ? &*obj : nullptr, stream);
-}
-
-// The first byte holds:
-// 0-4 1's (number of additional bytes) 0 (terminator) bits
-//
-// The number is represented as big-endian using the low order
-// bits of the first byte and all of the remaining bytes.
-//
-// Notes:
-// - values must be encoded using the minimum number of bytes,
-//   as non-canonical representations will break the sort order.
-template <typename S>
-void to_key_varuint32(std::uint32_t obj, S& stream) {
-   int num_bytes;
-   if (obj < 0x80u) {
-      num_bytes = 1;
-   } else if (obj < 0x4000u) {
-      num_bytes = 2;
-   } else if (obj < 0x200000u) {
-      num_bytes = 3;
-   } else if (obj < 0x10000000u) {
-      num_bytes = 4;
-   } else {
-      num_bytes = 5;
-   }
-
-   stream.write(
-         static_cast<char>(~(0xFFu >> (num_bytes - 1)) | (num_bytes == 5 ? 0 : (obj >> ((num_bytes - 1) * 8)))));
-   for (int i = num_bytes - 2; i >= 0; --i) { stream.write(static_cast<char>((obj >> i * 8) & 0xFFu)); }
-}
-
-// for non-negative values
-//  The first byte holds:
-//   1 (signbit) 0-4 1's (number of additional bytes) 0 (terminator) bits
-//  The value is represented as big endian
-// for negative values
-//  The first byte holds:
-//   0 (signbit) 0-4 0's (number of additional bytes) 1 (terminator) bits
-//   The value is adjusted to be positive based on the range that can
-//   be represented with this number of bytes and then encoded as big endian.
-//
-// Notes:
-// - negative values must sort before positive values
-// - For negative value, numbers that need more bytes are smaller, hence
-//   the encoding of the width must be opposite the encoding used for
-//   non-negative values.
-// - A 5-byte varint can represent values in $[-2^34, 2^34)$.  In this case,
-//   the argument will be sign-extended.
-template <typename S>
-void to_key_varint32(std::int32_t obj, S& stream) {
-   static_assert(std::is_same_v<S, void>, "to_key for varint32 has been temporarily disabled");
-   int  num_bytes;
-   bool sign = (obj < 0);
-   if (obj < 0x40 && obj >= -0x40) {
-      num_bytes = 1;
-   } else if (obj < 0x2000 && obj >= -0x2000) {
-      num_bytes = 2;
-   } else if (obj < 0x100000 && obj >= -0x100000) {
-      num_bytes = 3;
-   } else if (obj < 0x08000000 && obj >= -0x08000000) {
-      num_bytes = 4;
-   } else {
-      num_bytes = 5;
-   }
-
-   unsigned char width_field;
-   if (sign) {
-      width_field = 0x80u >> num_bytes;
-   } else {
-      width_field = 0x80u | ~(0xFFu >> num_bytes);
-   }
-   auto          uobj       = static_cast<std::uint32_t>(obj);
-   unsigned char value_mask = (0xFFu >> (num_bytes + 1));
-   unsigned char high_byte  = (num_bytes == 5 ? (sign ? 0xFF : 0) : (uobj >> ((num_bytes - 1) * 8)));
-   stream.write(width_field | (high_byte & value_mask));
-   for (int i = num_bytes - 2; i >= 0; --i) { stream.write(static_cast<char>((uobj >> i * 8) & 0xFFu)); }
-}
-
-template <typename... Ts, typename S>
-void to_key(const std::variant<Ts...>& obj, S& stream) {
-   to_key_varuint32(static_cast<uint32_t>(obj.index()), stream);
-   std::visit([&](const auto& item) { to_key(item, stream); }, obj);
-}
-
-template <typename S>
-void to_key(std::string_view obj, S& stream) {
-   for (char ch : obj) {
-      stream.write(ch);
-      if (ch == '\0') {
-         stream.write('\1');
-      }
-   }
-   stream.write("\0", 2);
-}
-
-template <typename S>
-void to_key(const std::string& obj, S& stream) {
-   to_key(std::string_view(obj), stream);
-}
-
-template <typename S>
-void to_key(bool obj, S& stream) {
-   stream.write(static_cast<char>(obj ? 1 : 0));
-}
-
-template <typename UInt, typename T>
-UInt float_to_key(T value) {
-   static_assert(sizeof(T) == sizeof(UInt), "Expected unsigned int of the same size");
-   UInt result;
-   std::memcpy(&result, &value, sizeof(T));
-   UInt signbit = (static_cast<UInt>(1) << (std::numeric_limits<UInt>::digits - 1));
-   UInt mask    = 0;
-   if (result == signbit)
-      result = 0;
-   if (result & signbit)
-      mask = ~mask;
-   return result ^ (mask | signbit);
-}
-
-template <typename T, typename S>
-void to_key(const T& obj, S& stream) {
-   if constexpr (std::is_floating_point_v<T>) {
-      if constexpr (sizeof(T) == 4) {
-         to_key(float_to_key<uint32_t>(obj), stream);
-      } else {
-         static_assert(sizeof(T) == 8, "Unknown floating point type");
-         to_key(float_to_key<uint64_t>(obj), stream);
-      }
-   } else if constexpr (std::is_integral_v<T>) {
-      auto v = static_cast<std::make_unsigned_t<T>>(obj);
-      v -= static_cast<std::make_unsigned_t<T>>(std::numeric_limits<T>::min());
-      std::reverse(reinterpret_cast<char*>(&v), reinterpret_cast<char*>(&v + 1));
-      stream.write_raw(v);
-   } else if constexpr (std::is_enum_v<T>) {
-      static_assert(!std::is_convertible_v<T, std::underlying_type_t<T>>, "Serializing unscoped enum");
-      to_key(static_cast<std::underlying_type_t<T>>(obj), stream);
-   } else {
-      eosio::for_each_field(obj, [&](const auto& member) {
-         to_key(member, stream);
-      });
-   }
-}
-
-template <typename T>
-void convert_to_key(const T& t, std::vector<char>& bin) {
-   size_stream ss;
-   to_key(t, ss);
-   auto orig_size = bin.size();
-   bin.resize(orig_size + ss.size);
-   fixed_buf_stream fbs(bin.data() + orig_size, ss.size);
-   to_key(t, fbs);
-   check( fbs.pos == fbs.end, convert_stream_error(stream_error::underrun) );
-}
-
-template <typename T>
-std::vector<char> convert_to_key(const T& t) {
-   std::vector<char> result;
-   convert_to_key(t, result);
-   return result;
-}
-
-} // namespace eosio

package/include/eosio/types.hpp

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <array>
-#include <cstdint>
-#include <optional>
-#include <string>
-#include <variant>
-#include <vector>
-
-namespace eosio {
-
-constexpr const char* get_type_name(bool*) { return "bool"; }
-constexpr const char* get_type_name(std::int8_t*) { return "int8"; }
-constexpr const char* get_type_name(std::uint8_t*) { return "uint8"; }
-constexpr const char* get_type_name(std::int16_t*) { return "int16"; }
-constexpr const char* get_type_name(std::uint16_t*) { return "uint16"; }
-constexpr const char* get_type_name(std::int32_t*) { return "int32"; }
-constexpr const char* get_type_name(std::uint32_t*) { return "uint32"; }
-constexpr const char* get_type_name(std::int64_t*) { return "int64"; }
-constexpr const char* get_type_name(std::uint64_t*) { return "uint64"; }
-constexpr const char* get_type_name(float*) { return "float32"; }
-constexpr const char* get_type_name(double*) { return "float64"; }
-constexpr const char* get_type_name(std::string*) { return "string"; }
-
-#ifndef ABIEOS_NO_INT128
-constexpr const char* get_type_name(__int128*) { return "int128"; }
-constexpr const char* get_type_name(unsigned __int128*) { return "uint128"; }
-#endif
-
-#ifdef __eosio_cdt__
-constexpr const char* get_type_name(long double*) { return "float128"; }
-#endif
-
-template <std::size_t N, std::size_t M>
-constexpr std::array<char, N + M> array_cat(std::array<char, N> lhs, std::array<char, M> rhs) {
-   std::array<char, N + M> result{};
-   for (int i = 0; i < N; ++i) { result[i] = lhs[i]; }
-   for (int i = 0; i < M; ++i) { result[i + N] = rhs[i]; }
-   return result;
-}
-
-template <std::size_t N>
-constexpr std::array<char, N> to_array(std::string_view s) {
-   std::array<char, N> result{};
-   for (int i = 0; i < N; ++i) { result[i] = s[i]; }
-   return result;
-}
-
-template <typename T, std::size_t N>
-constexpr auto append_type_name(const char (&suffix)[N]) {
-   constexpr std::string_view name = get_type_name((T*)nullptr);
-   return array_cat(to_array<name.size()>(name), to_array<N>({ suffix, N }));
-}
-
-template <typename T>
-constexpr auto vector_type_name = append_type_name<T>("[]");
-
-template <typename T>
-constexpr auto optional_type_name = append_type_name<T>("?");
-
-template <typename T>
-constexpr const char* get_type_name(std::vector<T>*) {
-   return vector_type_name<T>.data();
-}
-
-template <typename T>
-constexpr const char* get_type_name(std::optional<T>*) {
-   return optional_type_name<T>.data();
-}
-
-struct variant_type_appender {
-   char*                           buf;
-   constexpr variant_type_appender operator+(std::string_view s) {
-      *buf++ = '_';
-      for (auto ch : s) *buf++ = ch;
-      return *this;
-   }
-};
-
-template <typename... T>
-constexpr auto get_variant_type_name() {
-   constexpr std::size_t  size = sizeof("variant") + ((std::string_view(get_type_name((T*)nullptr)).size() + 1) + ...);
-   std::array<char, size> buffer{ 'v', 'a', 'r', 'i', 'a', 'n', 't' };
-   (variant_type_appender{ buffer.data() + 7 } + ... + std::string_view(get_type_name((T*)nullptr)));
-   buffer[buffer.size() - 1] = '\0';
-   return buffer;
-}
-
-template <typename... T>
-constexpr auto variant_type_name = get_variant_type_name<T...>();
-
-template <typename... T>
-constexpr const char* get_type_name(std::variant<T...>*) {
-   return variant_type_name<T...>.data();
-}
-
-} // namespace eosio