fc::variant Class Reference

stores null, int64, uint64, double, bool, string, std::vector<variant>, and variant_object's. More...

#include <variant.hpp>

Classes
class	visitor

Public Types
enum	type_id {   null_type = 0 , int64_type = 1 , uint64_type = 2 , double_type = 3 ,   bool_type = 4 , string_type = 5 , array_type = 6 , object_type = 7 ,   blob_type = 8 }

Public Member Functions
	variant ()
	Constructs a null_type variant.
	variant (nullptr_t)
	Constructs a null_type variant.
	variant (const char *str)
	variant (char *str)
	variant (wchar_t *str)
	variant (const wchar_t *str)
	variant (float val)
	variant (uint8_t val)
	variant (int8_t val)
	variant (uint16_t val)
	variant (int16_t val)
	variant (uint32_t val)
	variant (int32_t val)
	variant (uint64_t val)
	variant (int64_t val)
	variant (double val)
	variant (bool val)
	variant (blob val)
	variant (fc::string val)
	variant (variant_object)
	variant (mutable_variant_object)
	variant (variants)
	variant (const variant &)
	variant (variant &&)
	~variant ()
void	visit (const visitor &v) const
type_id	get_type () const
bool	is_null () const
bool	is_string () const
bool	is_bool () const
bool	is_int64 () const
bool	is_uint64 () const
bool	is_double () const
bool	is_object () const
bool	is_array () const
bool	is_blob () const
bool	is_numeric () const
bool	is_integer () const
int64_t	as_int64 () const
uint64_t	as_uint64 () const
bool	as_bool () const
double	as_double () const
blob &	get_blob ()
const blob &	get_blob () const
blob	as_blob () const
string	as_string () const
const string &	get_string () const
variants &	get_array ()
const variants &	get_array () const
variant_object &	get_object ()
const variant_object &	get_object () const
const variant &	operator[] (const char *) const
const variant &	operator[] (size_t pos) const
size_t	size () const
size_t	estimated_size () const
template<typename T >
T	as () const
template<typename T >
void	as (T &v) const
variant &	operator= (variant &&v)
variant &	operator= (const variant &v)
template<typename T >
variant &	operator= (T &&v)
template<typename T >
	variant (const std::optional< T > &v)
template<typename T >
	variant (const T &val)
template<typename T >
	variant (const T &val, const fc::yield_function_t &yield)
void	clear ()

Detailed Description

variant's allocate everything but strings, arrays, and objects on the stack and are 'move aware' for values allcoated on the heap.

Memory usage on 64 bit systems is 16 bytes and 12 bytes on 32 bit systems.

Definition at line 190 of file variant.hpp.

Member Enumeration Documentation

type_id

enum fc::variant::type_id

Enumerator
null_type
int64_type
uint64_type
double_type
bool_type
string_type
array_type
object_type
blob_type

Definition at line 193 of file variant.hpp.

        {
           null_type   = 0,
           int64_type  = 1,
           uint64_type = 2,
           double_type = 3,
           bool_type   = 4,
           string_type = 5,
           array_type  = 6,
           object_type = 7,
           blob_type   = 8
        };

Constructor & Destructor Documentation

variant() [1/27]

fc::variant::variant

(

)

Definition at line 24 of file variant.cpp.

{
   set_variant_type( this, null_type );
}

Here is the call graph for this function:

Here is the caller graph for this function:

variant() [2/27]

fc::variant::variant

(

fc::nullptr_t

)

Definition at line 29 of file variant.cpp.

{
   set_variant_type( this, null_type );
}

Here is the call graph for this function:

variant() [3/27]

fc::variant::variant

(

const char *

str

)

Parameters

str	- UTF8 string

Definition at line 106 of file variant.cpp.

{
   *reinterpret_cast<string**>(this)  = new string( str );
   set_variant_type( this, string_type );
}

Here is the call graph for this function:

variant() [4/27]

fc::variant::variant

(

char *

str

)

Definition at line 100 of file variant.cpp.

{
   *reinterpret_cast<string**>(this)  = new string( str );
   set_variant_type( this, string_type );
}

Here is the call graph for this function:

variant() [5/27]

fc::variant::variant

(

wchar_t *

str

)

Definition at line 113 of file variant.cpp.

{
   size_t len = wcslen(str);
   boost::scoped_array<char> buffer(new char[len]);
   for (unsigned i = 0; i < len; ++i)
     buffer[i] = (char)str[i];
   *reinterpret_cast<string**>(this)  = new string(buffer.get(), len);
   set_variant_type( this, string_type );
}

Here is the call graph for this function:

variant() [6/27]

fc::variant::variant

(

const wchar_t *

str

)

Definition at line 124 of file variant.cpp.

{
   size_t len = wcslen(str);
   boost::scoped_array<char> buffer(new char[len]);
   for (unsigned i = 0; i < len; ++i)
     buffer[i] = (char)str[i];
   *reinterpret_cast<string**>(this)  = new string(buffer.get(), len);
   set_variant_type( this, string_type );
}

Here is the call graph for this function:

variant() [7/27]

fc::variant::variant

(

float

val

)

Definition at line 82 of file variant.cpp.

{
   *reinterpret_cast<double*>(this)  = val;
   set_variant_type( this, double_type );
}

Here is the call graph for this function:

variant() [8/27]

fc::variant::variant

(

uint8_t

val

)

Definition at line 34 of file variant.cpp.

{
   *reinterpret_cast<uint64_t*>(this)  = val;
   set_variant_type( this, uint64_type );
}

Here is the call graph for this function:

variant() [9/27]

fc::variant::variant

(

int8_t

val

)

Definition at line 40 of file variant.cpp.

{
   *reinterpret_cast<int64_t*>(this)  = val;
   set_variant_type( this, int64_type );
}

Here is the call graph for this function:

variant() [10/27]

fc::variant::variant

(

uint16_t

val

)

Definition at line 46 of file variant.cpp.

{
   *reinterpret_cast<uint64_t*>(this)  = val;
   set_variant_type( this, uint64_type );
}

Here is the call graph for this function:

variant() [11/27]

fc::variant::variant

(

int16_t

val

)

Definition at line 52 of file variant.cpp.

{
   *reinterpret_cast<int64_t*>(this)  = val;
   set_variant_type( this, int64_type );
}

Here is the call graph for this function:

variant() [12/27]

fc::variant::variant

(

uint32_t

val

)

Definition at line 58 of file variant.cpp.

{
   *reinterpret_cast<uint64_t*>(this)  = val;
   set_variant_type( this, uint64_type );
}

Here is the call graph for this function:

variant() [13/27]

fc::variant::variant

(

int32_t

val

)

Definition at line 64 of file variant.cpp.

{
   *reinterpret_cast<int64_t*>(this)  = val;
   set_variant_type( this, int64_type );
}

Here is the call graph for this function:

variant() [14/27]

fc::variant::variant

(

uint64_t

val

)

Definition at line 70 of file variant.cpp.

{
   *reinterpret_cast<uint64_t*>(this)  = val;
   set_variant_type( this, uint64_type );
}

Here is the call graph for this function:

variant() [15/27]

fc::variant::variant

(

int64_t

val

)

Definition at line 76 of file variant.cpp.

{
   *reinterpret_cast<int64_t*>(this)  = val;
   set_variant_type( this, int64_type );
}

Here is the call graph for this function:

variant() [16/27]

fc::variant::variant

(

double

val

)

Definition at line 88 of file variant.cpp.

{
   *reinterpret_cast<double*>(this)  = val;
   set_variant_type( this, double_type );
}

Here is the call graph for this function:

variant() [17/27]

fc::variant::variant

(

bool

val

)

Definition at line 94 of file variant.cpp.

{
   *reinterpret_cast<bool*>(this)  = val;
   set_variant_type( this, bool_type );
}

Here is the call graph for this function:

variant() [18/27]

fc::variant::variant

(

blob

val

)

Definition at line 139 of file variant.cpp.

{
   *reinterpret_cast<blob**>(this)  = new blob( fc::move(val) );
   set_variant_type( this, blob_type );
}

Here is the call graph for this function:

variant() [19/27]

fc::variant::variant

(

fc::string

val

)

Definition at line 134 of file variant.cpp.

{
   *reinterpret_cast<string**>(this)  = new string( fc::move(val) );
   set_variant_type( this, string_type );
}

Here is the call graph for this function:

variant() [20/27]

fc::variant::variant

(

variant_object

obj

)

Definition at line 145 of file variant.cpp.

{
   *reinterpret_cast<variant_object**>(this)  = new variant_object(fc::move(obj));
   set_variant_type(this,  object_type );
}

Here is the call graph for this function:

variant() [21/27]

fc::variant::variant

(

mutable_variant_object

obj

)

Definition at line 150 of file variant.cpp.

{
   *reinterpret_cast<variant_object**>(this)  = new variant_object(fc::move(obj));
   set_variant_type(this,  object_type );
}

Here is the call graph for this function:

variant() [22/27]

fc::variant::variant

(

variants

arr

)

Definition at line 156 of file variant.cpp.

{
   *reinterpret_cast<variants**>(this)  = new variants(fc::move(arr));
   set_variant_type(this,  array_type );
}

Here is the call graph for this function:

variant() [23/27]

fc::variant::variant

(

const variant &

v

)

Definition at line 190 of file variant.cpp.

{
   switch( v.get_type() )
   {
       case object_type:
          *reinterpret_cast<variant_object**>(this)  =
             new variant_object(**reinterpret_cast<const const_variant_object_ptr*>(&v));
          set_variant_type( this, object_type );
          return;
       case array_type:
          *reinterpret_cast<variants**>(this)  =
             new variants(**reinterpret_cast<const const_variants_ptr*>(&v));
          set_variant_type( this,  array_type );
          return;
       case string_type:
          *reinterpret_cast<string**>(this)  =
             new string(**reinterpret_cast<const const_string_ptr*>(&v) );
          set_variant_type( this, string_type );
          return;
       case blob_type:
          *reinterpret_cast<blob**>(this)  =
             new blob(**reinterpret_cast<const const_blob_ptr*>(&v) );
          set_variant_type( this, blob_type );
          return;
       default:
          memcpy( this, &v, sizeof(v) );
   }
}

Here is the call graph for this function:

variant() [24/27]

fc::variant::variant

(

variant &&

v

)

Definition at line 219 of file variant.cpp.

{
   memcpy( this, &v, sizeof(v) );
   set_variant_type( &v, null_type );
}

Here is the call graph for this function:

~variant()

fc::variant::~variant

(

)

Definition at line 225 of file variant.cpp.

{
   clear();
}

Here is the call graph for this function:

variant() [25/27]

template<typename T >

fc::variant::variant ( const std::optional< T > & v )

inlineexplicit

Definition at line 350 of file variant.hpp.

        {
           memset( this, 0, sizeof(*this) );
           if( v.has_value() ) *this = variant(*v);
        }

Here is the call graph for this function:

variant() [26/27]

template<typename T >

fc::variant::variant ( const T & val )

explicit

Definition at line 616 of file variant.hpp.

   {
      memset( this, 0, sizeof(*this) );
      to_variant( val, *this );
   }

Here is the call graph for this function:

variant() [27/27]

template<typename T >

fc::variant::variant ( const T & val, const fc::yield_function_t & yield )

explicit

Definition at line 623 of file variant.hpp.

   {
      memset( this, 0, sizeof(*this) );
      to_variant( val, *this, yield );
   }

Here is the call graph for this function:

Member Function Documentation

as() [1/2]

template<typename T >

T fc::variant::as ( ) const

inline

_types that use non-intrusive variant conversion can implement the following method to implement conversion from variant to T.

void from_variant( const Variant& var, T& val )

The above form is not always convienant, so the this templated method is used to enable conversion from Variants to other types.

Definition at line 327 of file variant.hpp.

        {
           T tmp;
           from_variant( *this, tmp );
           return tmp;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

as() [2/2]

template<typename T >

void fc::variant::as ( T & v ) const

inline

Definition at line 335 of file variant.hpp.

        {
           from_variant( *this, v );
        }

Here is the call graph for this function:

as_blob()

blob fc::variant::as_blob

(

)

const

Definition at line 518 of file variant.cpp.

{
   switch( get_type() )
   {
      case null_type: return blob();
      case blob_type: return get_blob();
      case string_type:
      {
         const string& str = get_string();
         if( str.size() == 0 ) return blob();
         if( str.back() == '=' )
         {
            std::string b64 = base64_decode( get_string() );
            return blob( { std::vector<char>( b64.begin(), b64.end() ) } );
         }
         return blob( { std::vector<char>( str.begin(), str.end() ) } );
      }
      case object_type:
      case array_type:
         FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Blob", ("type",get_type()) );
      default:
         return blob( { std::vector<char>( (char*)&_data, (char*)&_data + sizeof(_data) ) } );
   }
}

Here is the call graph for this function:

as_bool()

bool fc::variant::as_bool

(

)

const

Definition at line 441 of file variant.cpp.

{
   switch( get_type() )
   {
      case string_type:
      {
          const string& s = **reinterpret_cast<const const_string_ptr*>(this);
          if( s == "true" )
             return true;
          if( s == "false" )
             return false;
          FC_THROW_EXCEPTION( bad_cast_exception, "Cannot convert string to bool (only \"true\" or \"false\" can be converted)" );
      }
      case double_type:
          return *reinterpret_cast<const double*>(this) != 0.0;
      case int64_type:
          return *reinterpret_cast<const int64_t*>(this) != 0;
      case uint64_type:
          return *reinterpret_cast<const uint64_t*>(this) != 0;
      case bool_type:
          return *reinterpret_cast<const bool*>(this);
      case null_type:
          return false;
      default:
         FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to bool" , ("type",get_type()));
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

as_double()

double fc::variant::as_double

(

)

const

Definition at line 420 of file variant.cpp.

{
   switch( get_type() )
   {
      case string_type:
          return to_double(**reinterpret_cast<const const_string_ptr*>(this));
      case double_type:
          return *reinterpret_cast<const double*>(this);
      case int64_type:
          return static_cast<double>(*reinterpret_cast<const int64_t*>(this));
      case uint64_type:
          return static_cast<double>(*reinterpret_cast<const uint64_t*>(this));
      case bool_type:
          return *reinterpret_cast<const bool*>(this);
      case null_type:
          return 0;
      default:
         FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to double", ("type",get_type()) );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

as_int64()

int64_t fc::variant::as_int64

(

)

const

Definition at line 377 of file variant.cpp.

{
   switch( get_type() )
   {
      case string_type:
          return to_int64(**reinterpret_cast<const const_string_ptr*>(this));
      case double_type:
          return int64_t(*reinterpret_cast<const double*>(this));
      case int64_type:
          return *reinterpret_cast<const int64_t*>(this);
      case uint64_type:
          return int64_t(*reinterpret_cast<const uint64_t*>(this));
      case bool_type:
          return *reinterpret_cast<const bool*>(this);
      case null_type:
          return 0;
      default:
         FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to int64", ("type", get_type()) );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

as_string()

string fc::variant::as_string

(

)

const

Convert's double, ints, bools, etc to a string

Exceptions

if	get_type() == array_type | get_type() == object_type

Definition at line 469 of file variant.cpp.

{
   switch( get_type() )
   {
      case string_type:
          return **reinterpret_cast<const const_string_ptr*>(this);
      case double_type:
          return to_string(*reinterpret_cast<const double*>(this));
      case int64_type:
          return to_string(*reinterpret_cast<const int64_t*>(this));
      case uint64_type:
          return to_string(*reinterpret_cast<const uint64_t*>(this));
      case bool_type:
          return *reinterpret_cast<const bool*>(this) ? "true" : "false";
      case blob_type:
          if( get_blob().data.size() )
             return base64_encode( get_blob().data.data(), get_blob().data.size() ) + "=";
          return string();
      case null_type:
          return string();
      default:
      FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to string", ("type", get_type() ) );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

as_uint64()

uint64_t fc::variant::as_uint64

(

)

const

Definition at line 398 of file variant.cpp.

{ try {
   switch( get_type() )
   {
      case string_type:
          return to_uint64(**reinterpret_cast<const const_string_ptr*>(this));
      case double_type:
          return static_cast<uint64_t>(*reinterpret_cast<const double*>(this));
      case int64_type:
          return static_cast<uint64_t>(*reinterpret_cast<const int64_t*>(this));
      case uint64_type:
          return *reinterpret_cast<const uint64_t*>(this);
      case bool_type:
          return static_cast<uint64_t>(*reinterpret_cast<const bool*>(this));
      case null_type:
          return 0;
      default:
         FC_THROW_EXCEPTION( bad_cast_exception,"Invalid cast from ${type} to uint64", ("type",get_type()));
   }
} FC_CAPTURE_AND_RETHROW( (*this) ) }

Here is the call graph for this function:

Here is the caller graph for this function:

clear()

void fc::variant::clear

(

)

Definition at line 168 of file variant.cpp.

{
   switch( get_type() )
   {
     case object_type:
        delete *reinterpret_cast<variant_object**>(this);
        break;
     case array_type:
        delete *reinterpret_cast<variants**>(this);
        break;
     case string_type:
        delete *reinterpret_cast<string**>(this);
        break;
     case blob_type:
        delete *reinterpret_cast<blob**>(this);
        break;
     default:
        break;
   }
   set_variant_type( this, null_type );
}

Here is the call graph for this function:

Here is the caller graph for this function:

estimated_size()

size_t fc::variant::estimated_size

(

)

const

Definition at line 575 of file variant.cpp.

{
   switch( get_type() )
   {
   case null_type:
   case int64_type:
   case uint64_type:
   case double_type:
   case bool_type:
      return sizeof(*this);
   case string_type:
      return as_string().length() + sizeof(string) + sizeof(*this);
   case array_type:
   {
      const auto& arr = get_array();
      auto arr_size = arr.size();
      size_t sum = sizeof(*this) + sizeof(variants);
      for (size_t iter = 0; iter < arr_size; ++iter) {
         sum += arr[iter].estimated_size();
      }
      return sum;
   }
   case object_type:
      return get_object().estimated_size() + sizeof(*this);
   case blob_type:
      return sizeof(blob) + get_blob().data.size() + sizeof(*this);
   default:
      FC_THROW_EXCEPTION( assert_exception, "Invalid Type / Corrupted Memory" );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_array() [1/2]

variants & fc::variant::get_array

(

)

Exceptions

if	get_type() != array_type | null_type

Definition at line 496 of file variant.cpp.

{
  if( get_type() == array_type )
     return **reinterpret_cast<variants**>(this);
 
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Array", ("type",get_type()) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_array() [2/2]

const variants & fc::variant::get_array

(

)

const

Exceptions

if	get_type() != array_type

Definition at line 545 of file variant.cpp.

{
  if( get_type() == array_type )
     return **reinterpret_cast<const const_variants_ptr*>(this);
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Array", ("type",get_type()) );
}

Here is the call graph for this function:

get_blob() [1/2]

blob & fc::variant::get_blob

(

)

Definition at line 503 of file variant.cpp.

{
  if( get_type() == blob_type )
     return **reinterpret_cast<blob**>(this);
 
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Blob", ("type",get_type()) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_blob() [2/2]

const blob & fc::variant::get_blob

(

)

const

Definition at line 510 of file variant.cpp.

{
  if( get_type() == blob_type )
     return **reinterpret_cast<const const_blob_ptr*>(this);
 
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Blob", ("type",get_type()) );
}

Here is the call graph for this function:

get_object() [1/2]

variant_object & fc::variant::get_object

(

)

Exceptions

if	get_type() != object_type | null_type

Definition at line 554 of file variant.cpp.

{
  if( get_type() == object_type )
     return **reinterpret_cast<variant_object**>(this);
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Object", ("type",get_type()) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_object() [2/2]

const variant_object & fc::variant::get_object

(

)

const

Exceptions

if	get_type() != object_type

Definition at line 614 of file variant.cpp.

{
  if( get_type() == object_type )
     return **reinterpret_cast<const const_variant_object_ptr*>(this);
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to Object", ("type",get_type()) );
}

Here is the call graph for this function:

get_string()

const string & fc::variant::get_string

(

)

const

Precondition

get_type() == string_type

Definition at line 606 of file variant.cpp.

{
  if( get_type() == string_type )
     return **reinterpret_cast<const const_string_ptr*>(this);
  FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to string", ("type",get_type()) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_type()

variant::type_id fc::variant::get_type

(

)

const

Definition at line 304 of file variant.cpp.

{
   return (type_id)reinterpret_cast<const char*>(this)[sizeof(*this)-1];
}

Here is the caller graph for this function:

is_array()

bool fc::variant::is_array

(

)

const

Definition at line 368 of file variant.cpp.

{
   return get_type() == array_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_blob()

bool fc::variant::is_blob

(

)

const

Definition at line 372 of file variant.cpp.

{
   return get_type() == blob_type;
}

Here is the call graph for this function:

is_bool()

bool fc::variant::is_bool

(

)

const

Definition at line 318 of file variant.cpp.

{
   return get_type() == bool_type;
}

Here is the call graph for this function:

is_double()

bool fc::variant::is_double

(

)

const

Definition at line 322 of file variant.cpp.

{
   return get_type() == double_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_int64()

bool fc::variant::is_int64

(

)

const

Definition at line 330 of file variant.cpp.

{
   return get_type() == int64_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_integer()

bool fc::variant::is_integer

(

)

const

int64, uint64, bool

Definition at line 335 of file variant.cpp.

{
   switch( get_type() )
   {
      case int64_type:
      case uint64_type:
      case bool_type:
         return true;
      default:
         return false;
   }
   return false;
}

Here is the call graph for this function:

is_null()

bool fc::variant::is_null

(

)

const

Definition at line 309 of file variant.cpp.

{
   return get_type() == null_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_numeric()

bool fc::variant::is_numeric

(

)

const

int64, uint64, double,bool

Definition at line 348 of file variant.cpp.

{
   switch( get_type() )
   {
      case int64_type:
      case uint64_type:
      case double_type:
      case bool_type:
         return true;
      default:
         return false;
   }
   return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_object()

bool fc::variant::is_object

(

)

const

Definition at line 363 of file variant.cpp.

{
   return get_type() == object_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_string()

bool fc::variant::is_string

(

)

const

Definition at line 314 of file variant.cpp.

{
   return get_type() == string_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_uint64()

bool fc::variant::is_uint64

(

)

const

Definition at line 326 of file variant.cpp.

{
   return get_type() == uint64_type;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/3]

variant & fc::variant::operator=

(

const variant &

v

)

Definition at line 239 of file variant.cpp.

{
   if( this == &v )
      return *this;
 
   clear();
   switch( v.get_type() )
   {
      case object_type:
         *reinterpret_cast<variant_object**>(this)  =
            new variant_object((**reinterpret_cast<const const_variant_object_ptr*>(&v)));
         break;
      case array_type:
         *reinterpret_cast<variants**>(this)  =
            new variants((**reinterpret_cast<const const_variants_ptr*>(&v)));
         break;
      case string_type:
         *reinterpret_cast<string**>(this)  = new string((**reinterpret_cast<const const_string_ptr*>(&v)) );
         break;
      case blob_type:
         *reinterpret_cast<blob**>(this)  = new blob((**reinterpret_cast<const const_blob_ptr*>(&v)) );
         break;
      default:
         memcpy( this, &v, sizeof(v) );
   }
   set_variant_type( this, v.get_type() );
   return *this;
}

Here is the call graph for this function:

operator=() [2/3]

template<typename T >

variant & fc::variant::operator= ( T && v )

inline

Definition at line 344 of file variant.hpp.

        {
           return *this = variant( fc::forward<T>(v) );
        }

Here is the call graph for this function:

operator=() [3/3]

variant & fc::variant::operator=

(

variant &&

v

)

Definition at line 230 of file variant.cpp.

{
   if( this == &v ) return *this;
   clear();
   memcpy( (char*)this, (char*)&v, sizeof(v) );
   set_variant_type( &v, null_type );
   return *this;
}

Here is the call graph for this function:

operator[]() [1/2]

const variant & fc::variant::operator[]

(

const char *

key

)

const

Precondition

is_object()

Definition at line 561 of file variant.cpp.

{
    return get_object()[key];
}

Here is the call graph for this function:

operator[]() [2/2]

const variant & fc::variant::operator[]

(

size_t

pos

)

const

Precondition

is_array()

Definition at line 565 of file variant.cpp.

{
    return get_array()[pos];
}

Here is the call graph for this function:

size()

size_t fc::variant::size

(

)

const

Precondition

is_array()

Definition at line 570 of file variant.cpp.

{
    return get_array().size();
}

Here is the call graph for this function:

visit()

void fc::variant::visit

(

const visitor &

v

)

const

Definition at line 268 of file variant.cpp.

{
   switch( get_type() )
   {
      case null_type:
         v.handle();
         return;
      case int64_type:
         v.handle( *reinterpret_cast<const int64_t*>(this) );
         return;
      case uint64_type:
         v.handle( *reinterpret_cast<const uint64_t*>(this) );
         return;
      case double_type:
         v.handle( *reinterpret_cast<const double*>(this) );
         return;
      case bool_type:
         v.handle( *reinterpret_cast<const bool*>(this) );
         return;
      case string_type:
         v.handle( **reinterpret_cast<const const_string_ptr*>(this) );
         return;
      case array_type:
         v.handle( **reinterpret_cast<const const_variants_ptr*>(this) );
         return;
      case object_type:
         v.handle( **reinterpret_cast<const const_variant_object_ptr*>(this) );
         return;
      case blob_type:
         v.handle( **reinterpret_cast<const const_blob_ptr*>(this) );
         return;
      default:
         FC_THROW_EXCEPTION( assert_exception, "Invalid Type / Corrupted Memory" );
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/fc/include/fc/variant.hpp
• libraries/fc/src/variant.cpp