sysio::chain::impl::abi_to_variant Struct Reference

#include <abi_serializer.hpp>

Classes
struct	add_static_variant

Static Public Member Functions
template<typename M , typename Resolver , not_require_abi_t< M > = 1>
static void	add (mutable_variant_object &mvo, const char *name, const M &v, Resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	add (mutable_variant_object &mvo, const char *name, const M &v, Resolver resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	add (mutable_variant_object &mvo, const char *name, const vector< M > &v, Resolver resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	add (mutable_variant_object &mvo, const char *name, const std::shared_ptr< M > &v, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver , typename... Args>
static void	add (mutable_variant_object &mvo, const char *name, const std::variant< Args... > &v, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static bool	add_special_logging (mutable_variant_object &mvo, const char *name, const action &act, Resolver &resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	add (mutable_variant_object &out, const char *name, const action &act, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	add (mutable_variant_object &out, const char *name, const action_trace &act_trace, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	add (mutable_variant_object &out, const char *name, const packed_transaction &ptrx, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	add (mutable_variant_object &out, const char *name, const transaction &trx, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	add (mutable_variant_object &out, const char *name, const signed_block &block, Resolver resolver, abi_traverse_context &ctx)

Detailed Description

Definition at line 331 of file abi_serializer.hpp.

Member Function Documentation

add() [1/10]

template<typename M , typename Resolver , require_abi_t< M > = 1>

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & mvo, const char * name, const M & v, Resolver resolver, abi_traverse_context & ctx )

static

template which overloads add for types which contain ABI information in their trees for these types we create new ABI aware visitors

add() [2/10]

template<typename M , typename Resolver , require_abi_t< M > >

void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & mvo, const char * name, const M & v, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

template which overloads add for types which are not relvant to ABI information and can be degraded to the normal ::to_variant(...) processing

Definition at line 337 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         mvo(name,v);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

add() [3/10]

template<typename M , typename Resolver , require_abi_t< M > = 1>

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & mvo, const char * name, const std::shared_ptr< M > & v, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

template which overloads add for shared_ptr of types which contain ABI information in their trees for these members we call add in order to trigger further processing

Definition at line 374 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         if( !v ) return;
         mutable_variant_object obj_mvo;
         add(obj_mvo, "_", *v, resolver, ctx);
         mvo(name, std::move(obj_mvo["_"]));
      }

Here is the call graph for this function:

add() [4/10]

template<typename Resolver , typename... Args>

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & mvo, const char * name, const std::variant< Args... > & v, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

Definition at line 401 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         mutable_variant_object obj_mvo;
         add_static_variant<Resolver> adder(obj_mvo, resolver, ctx);
         std::visit(adder, v);
         mvo(name, std::move(obj_mvo["_"]));
      }

Here is the call graph for this function:

add() [5/10]

template<typename M , typename Resolver , require_abi_t< M > = 1>

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & mvo, const char * name, const vector< M > & v, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

template which overloads add for vectors of types which contain ABI information in their trees for these members we call add in order to trigger further processing

Definition at line 355 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         vector<fc::variant> array;
         array.reserve(v.size());
 
         for (const auto& iter: v) {
            mutable_variant_object elem_mvo;
            add(elem_mvo, "_", iter, resolver, ctx);
            array.emplace_back(std::move(elem_mvo["_"]));
         }
         mvo(name, std::move(array));
      }

Here is the call graph for this function:

add() [6/10]

template<typename Resolver >

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & out, const char * name, const action & act, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

overload of to_variant_object for actions

This matches the FC_REFLECT for this type, but this is provided to extract the contents of act.data

Template Parameters

Resolver

Parameters

act
resolver

Returns

Definition at line 440 of file abi_serializer.hpp.

      {
         static_assert(fc::reflector<action>::total_member_count == 4);
         auto h = ctx.enter_scope();
         mutable_variant_object mvo;
         mvo("account", act.account);
         mvo("name", act.name);
         mvo("authorization", act.authorization);
 
         if( add_special_logging(mvo, name, act, resolver, ctx) ) {
            out(name, std::move(mvo));
            return;
         }
 
         auto set_hex_data = [&](mutable_variant_object& mvo, const char* name, const bytes& data) {
            if( !ctx.is_logging() ) {
               mvo(name, data);
            } else {
               fc::mutable_variant_object sub_obj;
               sub_obj( "size", data.size() );
               if( data.size() > impl::hex_log_max_size ) {
                  sub_obj( "trimmed_hex", std::vector<char>(&data[0], &data[0] + impl::hex_log_max_size) );
               } else {
                  sub_obj( "hex", data );
               }
               mvo(name, std::move(sub_obj));
            }
         };
 
         try {
            auto abi = resolver(act.account);
            if (abi) {
               auto type = abi->get_action_type(act.name);
               if (!type.empty()) {
                  try {
                     binary_to_variant_context _ctx(*abi, ctx, type);
                     _ctx.short_path = true; // Just to be safe while avoiding the complexity of threading an override boolean all over the place
                     mvo( "data", abi->_binary_to_variant( type, act.data, _ctx ));
                     set_hex_data(mvo, "hex_data", act.data);
                  } catch(...) {
                     // any failure to serialize data, then leave as not serailzed
                     set_hex_data(mvo, "data", act.data);
                  }
               } else {
                  set_hex_data(mvo, "data", act.data);
               }
            } else {
               set_hex_data(mvo, "data", act.data);
            }
         } catch(...) {
            set_hex_data(mvo, "data", act.data);
         }
         out(name, std::move(mvo));
      }

Here is the call graph for this function:

add() [7/10]

template<typename Resolver >

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & out, const char * name, const action_trace & act_trace, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

overload of to_variant_object for action_trace

This matches the FC_REFLECT for this type, but this is provided to extract the contents of action_trace.return_value

Template Parameters

Resolver

Parameters

action_trace
resolver

Returns

Definition at line 505 of file abi_serializer.hpp.

      {
         static_assert(fc::reflector<action_trace>::total_member_count == 17);
         auto h = ctx.enter_scope();
         mutable_variant_object mvo;
 
         mvo("action_ordinal", act_trace.action_ordinal);
         mvo("creator_action_ordinal", act_trace.creator_action_ordinal);
         mvo("closest_unnotified_ancestor_action_ordinal", act_trace.closest_unnotified_ancestor_action_ordinal);
         mvo("receipt", act_trace.receipt);
         mvo("receiver", act_trace.receiver);
         add(mvo, "act", act_trace.act, resolver, ctx);
         mvo("context_free", act_trace.context_free);
         mvo("elapsed", act_trace.elapsed);
         mvo("console", act_trace.console);
         mvo("trx_id", act_trace.trx_id);
         mvo("block_num", act_trace.block_num);
         mvo("block_time", act_trace.block_time);
         mvo("producer_block_id", act_trace.producer_block_id);
         mvo("account_ram_deltas", act_trace.account_ram_deltas);
         mvo("except", act_trace.except);
         mvo("error_code", act_trace.error_code);
 
         mvo("return_value_hex_data", act_trace.return_value);
         auto act = act_trace.act;
         try {
            auto abi = resolver(act.account);
            if (abi) {
               auto type = abi->get_action_result_type(act.name);
               if (!type.empty()) {
                  binary_to_variant_context _ctx(*abi, ctx, type);
                  _ctx.short_path = true; // Just to be safe while avoiding the complexity of threading an override boolean all over the place
                  mvo( "return_value_data", abi->_binary_to_variant( type, act_trace.return_value, _ctx ));
               }
            }
         } catch(...) {}
         out(name, std::move(mvo));
      }

Here is the call graph for this function:

add() [8/10]

template<typename Resolver >

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & out, const char * name, const packed_transaction & ptrx, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

overload of to_variant_object for packed_transaction

This matches the FC_REFLECT for this type, but this is provided to allow extracting the contents of ptrx.transaction

Template Parameters

Resolver

Parameters

act
resolver

Returns

Definition at line 554 of file abi_serializer.hpp.

      {
         static_assert(fc::reflector<packed_transaction>::total_member_count == 4);
         auto h = ctx.enter_scope();
         mutable_variant_object mvo;
         auto trx = ptrx.get_transaction();
         mvo("id", trx.id());
         mvo("signatures", ptrx.get_signatures());
         mvo("compression", ptrx.get_compression());
         mvo("packed_context_free_data", ptrx.get_packed_context_free_data());
         mvo("context_free_data", ptrx.get_context_free_data());
         if( !ctx.is_logging() )
            mvo("packed_trx", ptrx.get_packed_transaction());
         add(mvo, "transaction", trx, resolver, ctx);
 
         out(name, std::move(mvo));
      }

Here is the call graph for this function:

add() [9/10]

template<typename Resolver >

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & out, const char * name, const signed_block & block, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

overload of to_variant_object for signed_block

This matches the FC_REFLECT for this type, but this is provided to allow extracting the contents of block.header_extensions and block.block_extensions

Definition at line 609 of file abi_serializer.hpp.

      {
         static_assert(fc::reflector<signed_block>::total_member_count == 12);
         auto h = ctx.enter_scope();
         mutable_variant_object mvo;
         mvo("timestamp", block.timestamp);
         mvo("producer", block.producer);
         mvo("confirmed", block.confirmed);
         mvo("previous", block.previous);
         mvo("transaction_mroot", block.transaction_mroot);
         mvo("action_mroot", block.action_mroot);
         mvo("schedule_version", block.schedule_version);
         mvo("new_producers", block.new_producers);
 
         // process contents of block.header_extensions
         flat_multimap<uint16_t, block_header_extension> header_exts = block.validate_and_extract_header_extensions();
         if ( header_exts.count(protocol_feature_activation::extension_id() > 0) ) {
            const auto& new_protocol_features =
                  std::get<protocol_feature_activation>(header_exts.lower_bound(protocol_feature_activation::extension_id())->second).protocol_features;
            vector<fc::variant> pf_array;
            pf_array.reserve(new_protocol_features.size());
            for (auto feature : new_protocol_features) {
               mutable_variant_object feature_mvo;
               add(feature_mvo, "feature_digest", feature, resolver, ctx);
               pf_array.push_back(feature_mvo);
            }
            mvo("new_protocol_features", pf_array);
         }
         if ( header_exts.count(producer_schedule_change_extension::extension_id())) {
            const auto& new_producer_schedule =
                  std::get<producer_schedule_change_extension>(header_exts.lower_bound(producer_schedule_change_extension::extension_id())->second);
            mvo("new_producer_schedule", new_producer_schedule);
         }
 
         mvo("producer_signature", block.producer_signature);
         add(mvo, "transactions", block.transactions, resolver, ctx);
 
         // process contents of block.block_extensions
         auto block_exts = block.validate_and_extract_extensions();
         if ( block_exts.count(additional_block_signatures_extension::extension_id()) > 0) {
            const auto& additional_signatures =
                  std::get<additional_block_signatures_extension>(block_exts.lower_bound(additional_block_signatures_extension::extension_id())->second);
            mvo("additional_signatures", additional_signatures);
         }
 
         out(name, std::move(mvo));
      }

Here is the call graph for this function:

add() [10/10]

template<typename Resolver >

static void sysio::chain::impl::abi_to_variant::add ( mutable_variant_object & out, const char * name, const transaction & trx, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

overload of to_variant_object for transaction

This matches the FC_REFLECT for this type, but this is provided to allow extracting the contents of trx.transaction_extensions

Definition at line 578 of file abi_serializer.hpp.

      {
         static_assert(fc::reflector<transaction>::total_member_count == 9);
         auto h = ctx.enter_scope();
         mutable_variant_object mvo;
         mvo("expiration", trx.expiration);
         mvo("ref_block_num", trx.ref_block_num);
         mvo("ref_block_prefix", trx.ref_block_prefix);
         mvo("max_net_usage_words", trx.max_net_usage_words);
         mvo("max_cpu_usage_ms", trx.max_cpu_usage_ms);
         mvo("delay_sec", trx.delay_sec);
         add(mvo, "context_free_actions", trx.context_free_actions, resolver, ctx);
         add(mvo, "actions", trx.actions, resolver, ctx);
 
         // process contents of block.transaction_extensions
         auto exts = trx.validate_and_extract_extensions();
         if (exts.count(deferred_transaction_generation_context::extension_id()) > 0) {
            const auto& deferred_transaction_generation = std::get<deferred_transaction_generation_context>(exts.lower_bound(deferred_transaction_generation_context::extension_id())->second);
            mvo("deferred_transaction_generation", deferred_transaction_generation);
         }
 
         out(name, std::move(mvo));
      }

Here is the call graph for this function:

add_special_logging()

template<typename Resolver >

static bool sysio::chain::impl::abi_to_variant::add_special_logging ( mutable_variant_object & mvo, const char * name, const action & act, Resolver & resolver, abi_traverse_context & ctx )

inlinestatic

Definition at line 411 of file abi_serializer.hpp.

                                                                                                                                                         {
         if( !ctx.is_logging() ) return false;
 
         try {
 
            if( act.account == config::system_account_name && act.name == "setcode"_n ) {
               auto setcode_act = act.data_as<setcode>();
               if( setcode_act.code.size() > 0 ) {
                  fc::sha256 code_hash = fc::sha256::hash(setcode_act.code.data(), (uint32_t) setcode_act.code.size());
                  mvo("code_hash", code_hash);
               }
               return false; // still want the hex data included
            }
 
         } catch(...) {} // return false
 
         return false;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this struct was generated from the following file:

• libraries/chain/include/sysio/chain/abi_serializer.hpp