sysio::chain::impl::abi_from_variant Struct Reference

#include <abi_serializer.hpp>

Static Public Member Functions
template<typename M , typename Resolver , not_require_abi_t< M > = 1>
static void	extract (const fc::variant &v, M &o, Resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	extract (const fc::variant &v, M &o, Resolver resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	extract (const fc::variant &v, vector< M > &o, Resolver resolver, abi_traverse_context &ctx)
template<typename M , typename Resolver , require_abi_t< M > = 1>
static void	extract (const fc::variant &v, std::shared_ptr< M > &o, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	extract (const fc::variant &v, action &act, Resolver resolver, abi_traverse_context &ctx)
template<typename Resolver >
static void	extract (const fc::variant &v, packed_transaction &ptrx, Resolver resolver, abi_traverse_context &ctx)

Detailed Description

Definition at line 696 of file abi_serializer.hpp.

Member Function Documentation

extract() [1/6]

template<typename Resolver >

static void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, action & act, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

Non templated overload that has priority for the action structure this type has members which must be directly translated by the ABI so it is exploded and processed explicitly

Definition at line 753 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         const variant_object& vo = v.get_object();
         SYS_ASSERT(vo.contains("account"), packed_transaction_type_exception, "Missing account");
         SYS_ASSERT(vo.contains("name"), packed_transaction_type_exception, "Missing name");
         from_variant(vo["account"], act.account);
         from_variant(vo["name"], act.name);
 
         if (vo.contains("authorization")) {
            from_variant(vo["authorization"], act.authorization);
         }
 
         bool valid_empty_data = false;
         if( vo.contains( "data" ) ) {
            const auto& data = vo["data"];
            if( data.is_string() ) {
               from_variant(data, act.data);
               valid_empty_data = act.data.empty();
            } else if ( data.is_object() ) {
               auto abi = resolver(act.account);
               if (abi) {
                  auto type = abi->get_action_type(act.name);
                  if (!type.empty()) {
                     variant_to_binary_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
                     act.data = std::move( abi->_variant_to_binary( type, data, _ctx ));
                     valid_empty_data = act.data.empty();
                  }
               }
            }
         }
 
         if( !valid_empty_data && act.data.empty() ) {
            if( vo.contains( "hex_data" ) ) {
               const auto& data = vo["hex_data"];
               if( data.is_string() ) {
                  from_variant(data, act.data);
               }
            }
         }
 
         SYS_ASSERT(valid_empty_data || !act.data.empty(), packed_transaction_type_exception,
                    "Failed to deserialize data for ${account}:${name}", ("account", act.account)("name", act.name));
      }

Here is the call graph for this function:

extract() [2/6]

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

static void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, M & o, Resolver resolver, abi_traverse_context & ctx )

static

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

extract() [3/6]

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

void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, M & o, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

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

Definition at line 702 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         from_variant(v, o);
      }

Here is the call graph for this function:

Here is the caller graph for this function:

extract() [4/6]

template<typename Resolver >

static void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, packed_transaction & ptrx, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

Definition at line 800 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         const variant_object& vo = v.get_object();
         SYS_ASSERT(vo.contains("signatures"), packed_transaction_type_exception, "Missing signatures");
         SYS_ASSERT(vo.contains("compression"), packed_transaction_type_exception, "Missing compression");
         std::vector<signature_type> signatures;
         packed_transaction::compression_type compression;
         from_variant(vo["signatures"], signatures);
         from_variant(vo["compression"], compression);
 
         bytes packed_cfd;
         std::vector<bytes> cfd;
         bool use_packed_cfd = false;
         if( vo.contains("packed_context_free_data") && vo["packed_context_free_data"].is_string() && !vo["packed_context_free_data"].as_string().empty() ) {
            from_variant(vo["packed_context_free_data"], packed_cfd );
            use_packed_cfd = true;
         } else if( vo.contains("context_free_data") ) {
            from_variant(vo["context_free_data"], cfd);
         }
 
         if( vo.contains("packed_trx") && vo["packed_trx"].is_string() && !vo["packed_trx"].as_string().empty() ) {
            bytes packed_trx;
            from_variant(vo["packed_trx"], packed_trx);
            if( use_packed_cfd ) {
               ptrx = packed_transaction( std::move( packed_trx ), std::move( signatures ), std::move( packed_cfd ), compression );
            } else {
               ptrx = packed_transaction( std::move( packed_trx ), std::move( signatures ), std::move( cfd ), compression );
            }
         } else {
            SYS_ASSERT(vo.contains("transaction"), packed_transaction_type_exception, "Missing transaction");
            if( use_packed_cfd ) {
               transaction trx;
               extract( vo["transaction"], trx, resolver, ctx );
               ptrx = packed_transaction( std::move(trx), std::move(signatures), std::move(packed_cfd), compression );
            } else {
               signed_transaction trx;
               extract( vo["transaction"], trx, resolver, ctx );
               trx.signatures = std::move( signatures );
               trx.context_free_data = std::move(cfd);
               ptrx = packed_transaction( std::move( trx ), compression );
            }
         }
      }

Here is the call graph for this function:

extract() [5/6]

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

static void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, std::shared_ptr< M > & o, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

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

Definition at line 738 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         const variant_object& vo = v.get_object();
         M obj;
         extract(vo, obj, resolver, ctx);
         o = std::make_shared<M>(obj);
      }

Here is the call graph for this function:

extract() [6/6]

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

static void sysio::chain::impl::abi_from_variant::extract ( const fc::variant & v, vector< M > & o, Resolver resolver, abi_traverse_context & ctx )

inlinestatic

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

Definition at line 720 of file abi_serializer.hpp.

      {
         auto h = ctx.enter_scope();
         const variants& array = v.get_array();
         o.clear();
         o.reserve( array.size() );
         for( auto itr = array.begin(); itr != array.end(); ++itr ) {
            M o_iter;
            extract(*itr, o_iter, resolver, ctx);
            o.emplace_back(std::move(o_iter));
         }
      }

Here is the call graph for this function:

---

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

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