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

package/include/eosio/from_string.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "stream.hpp"
-#include <string_view>
-
-namespace eosio {
-
-template <typename T, typename S>
-T from_string(S& stream) {
-   T    obj;
-   from_string(obj, stream);
-   return obj;
-}
-
-template <typename T>
-void convert_from_string(T& obj, std::string_view s) {
-   input_stream stream{ s };
-   from_string(obj, stream);
-}
-
-template <typename T>
-T convert_from_string(std::string_view s) {
-   T    obj;
-   convert_from_string(obj, s);
-   return obj;
-}
-
-} // namespace eosio

package/include/eosio/map_macro.h

@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2012 William Swanson
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * Except as contained in this notice, the names of the authors or
- * their institutions shall not be used in advertising or otherwise to
- * promote the sale, use or other dealings in this Software without
- * prior written authorization from the authors.
- */
-
-/*
- * This file has been modified by block.one
- */
-
-#ifndef EOSIO_MAP_MACRO_H_INCLUDED
-#define EOSIO_MAP_MACRO_H_INCLUDED
-
-#define EOSIO_EVAL0(...) __VA_ARGS__
-#define EOSIO_EVAL1(...) EOSIO_EVAL0(EOSIO_EVAL0(EOSIO_EVAL0(__VA_ARGS__)))
-#define EOSIO_EVAL2(...) EOSIO_EVAL1(EOSIO_EVAL1(EOSIO_EVAL1(__VA_ARGS__)))
-#define EOSIO_EVAL3(...) EOSIO_EVAL2(EOSIO_EVAL2(EOSIO_EVAL2(__VA_ARGS__)))
-#define EOSIO_EVAL4(...) EOSIO_EVAL3(EOSIO_EVAL3(EOSIO_EVAL3(__VA_ARGS__)))
-#define EOSIO_EVAL(...) EOSIO_EVAL4(EOSIO_EVAL4(EOSIO_EVAL4(__VA_ARGS__)))
-
-#define EOSIO_MAP_END(...)
-#define EOSIO_MAP_OUT
-
-#define EOSIO_MAP_GET_END2() 0, EOSIO_MAP_END
-#define EOSIO_MAP_GET_END1(...) EOSIO_MAP_GET_END2
-#define EOSIO_MAP_GET_END(...) EOSIO_MAP_GET_END1
-#define EOSIO_MAP_NEXT0(test, next, ...) next EOSIO_MAP_OUT
-#define EOSIO_MAP_NEXT1(test, next) EOSIO_MAP_NEXT0(test, next, 0)
-#define EOSIO_MAP_NEXT(test, next) EOSIO_MAP_NEXT1(EOSIO_MAP_GET_END test, next)
-
-// Macros below this point added by block.one
-
-#define EOSIO_MAP_REUSE_ARG0_0(f, arg0, x, peek, ...)                                                                  \
-   f(arg0, x) EOSIO_MAP_NEXT(peek, EOSIO_MAP_REUSE_ARG0_1)(f, arg0, peek, __VA_ARGS__)
-#define EOSIO_MAP_REUSE_ARG0_1(f, arg0, x, peek, ...)                                                                  \
-   f(arg0, x) EOSIO_MAP_NEXT(peek, EOSIO_MAP_REUSE_ARG0_0)(f, arg0, peek, __VA_ARGS__)
-// Handle 0 arguments
-#define EOSIO_MAP_REUSE_ARG0_I(f, arg0, peek, ...)                                                                     \
-   EOSIO_MAP_NEXT(peek, EOSIO_MAP_REUSE_ARG0_1)(f, arg0, peek, __VA_ARGS__)
-#define EOSIO_MAP_REUSE_ARG0(f, ...) EOSIO_EVAL(EOSIO_MAP_REUSE_ARG0_I(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
-
-#endif

package/include/eosio/murmur.hpp

@@ -1,55 +0,0 @@
-  
-namespace eosio {
-namespace {
-  inline constexpr uint64_t unaligned_load(const char* p)
-  {
-    uint64_t r = 0;
-    for( uint32_t i = 0; i < 8; ++i ) {
-       r |= p[i];
-       r <<= 8;
-    }
-    return r;
-  }
-
-  // Loads n bytes, where 1 <= n < 8.
-  inline constexpr uint64_t load_bytes(const char* p, int n)
-  {
-    std::uint64_t result = 0;
-    --n;
-    do
-      result = (result << 8) +  (unsigned char)(p[n]);
-    while (--n >= 0);
-    return result;
-  }
-
-  inline constexpr uint64_t shift_mix(std::uint64_t v)
-  { return v ^ (v >> 47);}
-}
-
-// Implementation of Murmur hash for 64-bit size_t.
-  inline constexpr uint64_t murmur64(const char* ptr, uint64_t len, uint64_t seed = 0xbadd00d00)
-  {
-    const uint64_t mul = (((uint64_t) 0xc6a4a793UL) << 32UL)
-			      + (uint64_t) 0x5bd1e995UL;
-    const char* const buf = ptr;
-
-    // Remove the bytes not divisible by the sizeof(uint64_t).  This
-    // allows the main loop to process the data as 64-bit integers.
-    const uint64_t len_aligned = len & ~(uint64_t)0x7;
-    const char* const end = buf + len_aligned;
-    uint64_t hash = seed ^ (len * mul);
-    for (const char* p = buf; p != end; p += 8) {
-     const uint64_t data = shift_mix(unaligned_load(p) * mul) * mul;
-     hash ^= data;
-     hash *= mul;
-    }
-    if ((len & 0x7) != 0) {
-     const uint64_t data = load_bytes(end, len & 0x7);
-     hash ^= data;
-     hash *= mul;
-    }
-    hash = shift_mix(hash) * mul;
-    hash = shift_mix(hash);
-    return hash;
-  }
-} // namespace eosio

package/include/eosio/name.hpp

@@ -1,174 +0,0 @@
-#pragma once
-
-#include "chain_conversions.hpp"
-#include "check.hpp"
-#include "operators.hpp"
-#include "reflection.hpp"
-#include "murmur.hpp"
-#include <string>
-
-namespace eosio {
-
-struct name {
-   enum class raw : uint64_t {};
-   uint64_t value = 0;
-
-   constexpr name() = default;
-   constexpr explicit name(uint64_t value) : value{ value } {}
-   constexpr explicit name(name::raw value) : value{ static_cast<uint64_t>(value) } {}
-   constexpr explicit name(std::string_view str) : value{ string_to_name_strict(str) } { }
-
-   constexpr name(const name&) = default;
-
-   constexpr   operator raw() const { return static_cast<raw>(value); }
-   explicit    operator std::string() const { return eosio::name_to_string(value); }
-   std::string to_string() const { return std::string(*this); }
-   /**
-    * Explicit cast to bool of the uint64_t value of the name
-    *
-    * @return Returns true if the name is set to the default value of 0 else true.
-    */
-   constexpr explicit operator bool() const { return value != 0; }
-
-   /**
-    *  Converts a %name Base32 symbol into its corresponding value
-    *
-    *  @param c - Character to be converted
-    *  @return constexpr char - Converted value
-    */
-   static constexpr uint8_t char_to_value(char c) {
-      if (c == '.')
-         return 0;
-      else if (c >= '1' && c <= '5')
-         return (c - '1') + 1;
-      else if (c >= 'a' && c <= 'z')
-         return (c - 'a') + 6;
-      else
-         eosio::check(false, "character is not in allowed character set for names");
-
-      return 0; // control flow will never reach here; just added to suppress warning
-   }
-
-   /**
-    *  Returns the length of the %name
-    */
-   constexpr uint8_t length() const {
-      constexpr uint64_t mask = 0xF800000000000000ull;
-
-      if (value == 0)
-         return 0;
-
-      uint8_t l = 0;
-      uint8_t i = 0;
-      for (auto v = value; i < 13; ++i, v <<= 5) {
-         if ((v & mask) > 0) {
-            l = i;
-         }
-      }
-
-      return l + 1;
-   }
-
-   /**
-    *  Returns the suffix of the %name
-    */
-   constexpr name suffix() const {
-      uint32_t remaining_bits_after_last_actual_dot = 0;
-      uint32_t tmp                                  = 0;
-      for (int32_t remaining_bits = 59; remaining_bits >= 4;
-           remaining_bits -= 5) { // Note: remaining_bits must remain signed integer
-         // Get characters one-by-one in name in order from left to right (not including the 13th character)
-         auto c = (value >> remaining_bits) & 0x1Full;
-         if (!c) { // if this character is a dot
-            tmp = static_cast<uint32_t>(remaining_bits);
-         } else { // if this character is not a dot
-            remaining_bits_after_last_actual_dot = tmp;
-         }
-      }
-
-      uint64_t thirteenth_character = value & 0x0Full;
-      if (thirteenth_character) { // if 13th character is not a dot
-         remaining_bits_after_last_actual_dot = tmp;
-      }
-
-      if (remaining_bits_after_last_actual_dot ==
-          0) // there is no actual dot in the %name other than potentially leading dots
-         return name{ value };
-
-      // At this point remaining_bits_after_last_actual_dot has to be within the range of 4 to 59 (and restricted to
-      // increments of 5).
-
-      // Mask for remaining bits corresponding to characters after last actual dot, except for 4 least significant bits
-      // (corresponds to 13th character).
-      uint64_t mask  = (1ull << remaining_bits_after_last_actual_dot) - 16;
-      uint32_t shift = 64 - remaining_bits_after_last_actual_dot;
-
-      return name{ ((value & mask) << shift) + (thirteenth_character << (shift - 1)) };
-   }
-
-   /**
-    *  Returns the prefix of the %name
-    */
-   constexpr name prefix() const {
-      uint64_t result                 = value;
-      bool     not_dot_character_seen = false;
-      uint64_t mask                   = 0xFull;
-
-      // Get characters one-by-one in name in order from right to left
-      for (int32_t offset = 0; offset <= 59;) {
-         auto c = (value >> offset) & mask;
-
-         if (!c) {                        // if this character is a dot
-            if (not_dot_character_seen) { // we found the rightmost dot character
-               result = (value >> offset) << offset;
-               break;
-            }
-         } else {
-            not_dot_character_seen = true;
-         }
-
-         if (offset == 0) {
-            offset += 4;
-            mask = 0x1Full;
-         } else {
-            offset += 5;
-         }
-      }
-
-      return name{ result };
-   }
-};
-
-// TODO this seems weird and the name is misleading
-// and I don't think this has ever been truly constexpr
-inline constexpr uint64_t hash_name( std::string_view str ) {
-   auto r = try_string_to_name_strict(str);
-   if( r ) return r.value();
-   return  murmur64( str.data(), str.size() );
-}
-
-EOSIO_REFLECT(name, value);
-EOSIO_COMPARE(name);
-
-template <typename S>
-void from_json(name& obj, S& stream) {
-   auto r = stream.get_string();
-   obj = name(hash_name(r));
-}
-
-template <typename S>
-void to_json(const name& obj, S& stream) {
-   to_json(eosio::name_to_string(obj.value), stream);
-}
-
-inline namespace literals {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
-   template <typename T, T... Str>
-   inline constexpr name operator""_n() {
-      return name(string_to_name_strict<Str...>()); }
-   inline constexpr name operator""_h(const char* s, size_t) { return name( hash_name(s) ); }
-#pragma clang diagnostic pop
-} // namespace literals
-
-} // namespace eosio

package/include/eosio/opaque.hpp

@@ -1,108 +0,0 @@
-#pragma once
-
-#include "from_bin.hpp"
-#include "stream.hpp"
-#include "types.hpp"
-
-namespace eosio {
-
-///
-/// opaque<T> type provides a type safe alternative to input_stream to declare a field
-/// to be skiped during deserialization of its containing data structure. Afterwards, 
-/// the underlying value can be restored with correct type information. 
-///
-/// The serialization opaque<T> consists of a variable length byte count followed by the 
-/// serialized bytes for a value of type T. The purpose to serialized as opaque<T> as oppose
-/// to T is to allow the client to delay deserialization until the value is actually needed and
-/// thus saving some CPU cycles or memory requirement. 
-///
-/// For example, given a foo_type,
-/// 
-/// <code>
-///    struct foo_type {
-///      uint32_t                    field1;
-///      string                      field2;
-///      opaque<std::vector<string>> field3;
-///    };
-/// </code>
-///   
-/// the deserialization can be implemented as follows:
-/// 
-/// <code>  
-///   input_stream serialized_foo_stream(...);
-///   foo_type foo_value; 
-///   from_bin(foo_value, serialized_foo_stream);
-///   if (foo_value.field1 > 1 || foo_value.field2 == "meet_precondition") {
-///      auto sz = foo_value.field3.unpack_size();
-///      for (size_t i = 0; i < sz; ++i) {
-///         if (foo_value.field3.unpack_next() == "value_to_be_searched") {
-///            do_something_when_found();
-///            break;
-///         }
-///      }
-///   }
-/// </code>
-
-template <typename T>
-class opaque_base {
- protected:
-   input_stream bin;
-
- public:
-   opaque_base() = default;
-   explicit opaque_base(const std::vector<char>& data) : bin(data) {}
-   explicit opaque_base(input_stream strm) { eosio::from_bin(bin, strm); }
-
-   void unpack(T& obj) { eosio::from_bin(obj, bin); }
-
-   T unpack() {
-      T obj;
-      this->unpack(obj);
-      return obj;
-   }
-
-   bool empty() const { return !bin.remaining(); }
-
-   template <typename S>
-   void from(S& stream) {
-      eosio::from_bin(this->bin, stream);
-   }
-};
-
-template <typename T>
-class opaque : public opaque_base<T> {
- public:
-   using opaque_base<T>::opaque_base;
-};
-
-template <typename T>
-class opaque<std::vector<T>> : public opaque_base<std::vector<T>> {
- public:
-   using opaque_base<std::vector<T>>::opaque_base;
-
-   size_t unpack_size() {
-      uint32_t num;
-      varuint32_from_bin(num, this->bin);
-      return num;
-   }
-
-   void unpack_next(T& obj) { eosio::from_bin(obj, this->bin); }
-
-   T unpack_next() {
-      T obj;
-      this->unpack_next(obj);
-      return obj;
-   }
-};
-
-template <typename T>
-constexpr const char* get_type_name(opaque<T>*) {
-   return "bytes";
-}
-
-template <typename T, typename S>
-void from_bin(opaque<T>& obj, S& stream) {
-   obj.from(stream);
-}
-
-} // namespace eosio

package/include/eosio/operators.hpp

@@ -1,71 +0,0 @@
-#pragma once
-
-#include "for_each_field.hpp"
-
-namespace eosio { namespace operators {
-
-// Defines comparison operators for a reflected struct
-#define EOSIO_COMPARE(...)                                                                                             \
-   auto                      eosio_enable_comparison(const __VA_ARGS__&)->bool;                                        \
-   using ::eosio::operators::operator==;                                                                               \
-   using ::eosio::operators::operator!=;                                                                               \
-   using ::eosio::operators::operator<;                                                                                \
-   using ::eosio::operators::operator>;                                                                                \
-   using ::eosio::operators::operator<=;                                                                               \
-   using ::eosio::operators::operator>=;                                                                               \
-   using ::eosio::operators::eosio_compare
-
-   template <typename T>
-   constexpr auto operator==(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      bool result = true;
-      for_each_field<T>([&](const char*, auto&& member) { result = result && (member(&lhs) == member(&rhs)); });
-      return result;
-   }
-   template <typename T>
-   constexpr auto operator!=(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      return !(lhs == rhs);
-   }
-
-   namespace internal_use_do_not_use {
-      // This is a worse match than the user-visible overload
-      template <typename T, typename U>
-      constexpr int eosio_compare(const T& lhs, const U& rhs) {
-         if (lhs < rhs)
-            return -1;
-         else if (rhs < lhs)
-            return 1;
-         else
-            return 0;
-      }
-   } // namespace internal_use_do_not_use
-
-   template <typename T>
-   constexpr auto eosio_compare(const T& lhs, const T& rhs) -> decltype((eosio_enable_comparison(lhs), 0)) {
-      int result = 0;
-      for_each_field<T>([&](const char*, auto&& member) {
-         if (!result) {
-            using internal_use_do_not_use::eosio_compare;
-            result = eosio_compare(member(&lhs), member(&rhs));
-         }
-      });
-      return result;
-   }
-
-   template <typename T>
-   constexpr auto operator<(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      return eosio_compare(lhs, rhs) < 0;
-   }
-   template <typename T>
-   constexpr auto operator>(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      return eosio_compare(lhs, rhs) > 0;
-   }
-   template <typename T>
-   constexpr auto operator<=(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      return eosio_compare(lhs, rhs) <= 0;
-   }
-   template <typename T>
-   constexpr auto operator>=(const T& lhs, const T& rhs) -> decltype(eosio_enable_comparison(lhs)) {
-      return eosio_compare(lhs, rhs) >= 0;
-   }
-
-}} // namespace eosio::operators

package/include/eosio/powers.h

@@ -1,76 +0,0 @@
-/// From https://github.com/night-shift/fpconv
-/// Boost Software License 1.0
-/// See accompanying license file
-
-#pragma once
-
-#include <stdint.h>
-
-#define npowers 87
-#define steppowers 8
-#define firstpower -348 /* 10 ^ -348 */
-
-#define expmax -32
-#define expmin -60
-
-typedef struct Fp {
-   uint64_t frac;
-   int      exp;
-} Fp;
-
-static Fp powers_ten[] = {
-   { 18054884314459144840U, -1220 }, { 13451937075301367670U, -1193 }, { 10022474136428063862U, -1166 },
-   { 14934650266808366570U, -1140 }, { 11127181549972568877U, -1113 }, { 16580792590934885855U, -1087 },
-   { 12353653155963782858U, -1060 }, { 18408377700990114895U, -1034 }, { 13715310171984221708U, -1007 },
-   { 10218702384817765436U, -980 },  { 15227053142812498563U, -954 },  { 11345038669416679861U, -927 },
-   { 16905424996341287883U, -901 },  { 12595523146049147757U, -874 },  { 9384396036005875287U, -847 },
-   { 13983839803942852151U, -821 },  { 10418772551374772303U, -794 },  { 15525180923007089351U, -768 },
-   { 11567161174868858868U, -741 },  { 17236413322193710309U, -715 },  { 12842128665889583758U, -688 },
-   { 9568131466127621947U, -661 },   { 14257626930069360058U, -635 },  { 10622759856335341974U, -608 },
-   { 15829145694278690180U, -582 },  { 11793632577567316726U, -555 },  { 17573882009934360870U, -529 },
-   { 13093562431584567480U, -502 },  { 9755464219737475723U, -475 },   { 14536774485912137811U, -449 },
-   { 10830740992659433045U, -422 },  { 16139061738043178685U, -396 },  { 12024538023802026127U, -369 },
-   { 17917957937422433684U, -343 },  { 13349918974505688015U, -316 },  { 9946464728195732843U, -289 },
-   { 14821387422376473014U, -263 },  { 11042794154864902060U, -236 },  { 16455045573212060422U, -210 },
-   { 12259964326927110867U, -183 },  { 18268770466636286478U, -157 },  { 13611294676837538539U, -130 },
-   { 10141204801825835212U, -103 },  { 15111572745182864684U, -77 },   { 11258999068426240000U, -50 },
-   { 16777216000000000000U, -24 },   { 12500000000000000000U, 3 },     { 9313225746154785156U, 30 },
-   { 13877787807814456755U, 56 },    { 10339757656912845936U, 83 },    { 15407439555097886824U, 109 },
-   { 11479437019748901445U, 136 },   { 17105694144590052135U, 162 },   { 12744735289059618216U, 189 },
-   { 9495567745759798747U, 216 },    { 14149498560666738074U, 242 },   { 10542197943230523224U, 269 },
-   { 15709099088952724970U, 295 },   { 11704190886730495818U, 322 },   { 17440603504673385349U, 348 },
-   { 12994262207056124023U, 375 },   { 9681479787123295682U, 402 },    { 14426529090290212157U, 428 },
-   { 10748601772107342003U, 455 },   { 16016664761464807395U, 481 },   { 11933345169920330789U, 508 },
-   { 17782069995880619868U, 534 },   { 13248674568444952270U, 561 },   { 9871031767461413346U, 588 },
-   { 14708983551653345445U, 614 },   { 10959046745042015199U, 641 },   { 16330252207878254650U, 667 },
-   { 12166986024289022870U, 694 },   { 18130221999122236476U, 720 },   { 13508068024458167312U, 747 },
-   { 10064294952495520794U, 774 },   { 14996968138956309548U, 800 },   { 11173611982879273257U, 827 },
-   { 16649979327439178909U, 853 },   { 12405201291620119593U, 880 },   { 9242595204427927429U, 907 },
-   { 13772540099066387757U, 933 },   { 10261342003245940623U, 960 },   { 15290591125556738113U, 986 },
-   { 11392378155556871081U, 1013 },  { 16975966327722178521U, 1039 },  { 12648080533535911531U, 1066 }
-};
-
-static Fp find_cachedpow10(int exp, int* k) {
-   const double one_log_ten = 0.30102999566398114;
-
-   int approx = -(exp + npowers) * one_log_ten;
-   int idx    = (approx - firstpower) / steppowers;
-
-   while (1) {
-      int current = exp + powers_ten[idx].exp + 64;
-
-      if (current < expmin) {
-         idx++;
-         continue;
-      }
-
-      if (current > expmax) {
-         idx--;
-         continue;
-      }
-
-      *k = (firstpower + idx * steppowers);
-
-      return powers_ten[idx];
-   }
-}

package/include/eosio/reflection.hpp

@@ -1,61 +0,0 @@
-#pragma once
-
-#include "map_macro.h"
-#include <type_traits>
-
-namespace eosio { namespace reflection {
-
-   template <typename T>
-   struct has_for_each_field {
-    private:
-      struct F {
-         template <typename A, typename B>
-         void operator()(const A&, const B&);
-      };
-
-      template <typename C>
-      static char test(decltype(eosio_for_each_field((C*)nullptr, std::declval<F>()))*);
-
-      template <typename C>
-      static long test(...);
-
-    public:
-      static constexpr bool value = sizeof(test<T>((void*)nullptr)) == sizeof(char);
-   };
-
-   template <typename T>
-   inline constexpr bool has_for_each_field_v = has_for_each_field<T>::value;
-
-#define EOSIO_REFLECT_MEMBER(STRUCT, FIELD)                                                                            \
-   f(#FIELD, [](auto p) -> decltype(&std::decay_t<decltype(*p)>::FIELD) { return &std::decay_t<decltype(*p)>::FIELD; });
-
-#define EOSIO_REFLECT_STRIP_BASEbase
-#define EOSIO_REFLECT_BASE(STRUCT, BASE)                                                                               \
-   static_assert(std::is_base_of_v<EOSIO_REFLECT_STRIP_BASE##BASE, STRUCT>, #BASE " is not a base class of " #STRUCT); \
-   eosio_for_each_field((EOSIO_REFLECT_STRIP_BASE##BASE*)nullptr, f);
-
-#define EOSIO_REFLECT_SIGNATURE(STRUCT, ...)                                                                           \
-   [[maybe_unused]] inline const char* get_type_name(STRUCT*) { return #STRUCT; }                                      \
-   template <typename F>                                                                                               \
-   constexpr void eosio_for_each_field(STRUCT*, F f)
-
-/**
- * EOSIO_REFLECT(<struct>, <member or base spec>...)
- * Each parameter should be either the keyword 'base' followed by a base class of the struct or
- * an identifier which names a non-static data member of the struct.
- */
-#define EOSIO_REFLECT(...)                                                                                             \
-   EOSIO_REFLECT_SIGNATURE(__VA_ARGS__) { EOSIO_MAP_REUSE_ARG0(EOSIO_REFLECT_INTERNAL, __VA_ARGS__) }
-
-// Identity the keyword 'base' followed by at least one token
-#define EOSIO_REFLECT_SELECT_I(a, b, c, d, ...) EOSIO_REFLECT_##d
-#define EOSIO_REFLECT_IS_BASE() ~, ~
-#define EOSIO_REFLECT_IS_BASE_TESTbase ~, EOSIO_REFLECT_IS_BASE
-
-#define EOSIO_APPLY(m, x) m x
-#define EOSIO_CAT(x, y) x##y
-#define EOSIO_REFLECT_INTERNAL(STRUCT, FIELD)                                                                          \
-   EOSIO_APPLY(EOSIO_REFLECT_SELECT_I, (EOSIO_CAT(EOSIO_REFLECT_IS_BASE_TEST, FIELD()), MEMBER, BASE, MEMBER))         \
-   (STRUCT, FIELD)
-
-}} // namespace eosio::reflection