Ejemplo n.º 1
0
   void to_stream( T& os, const variant& v, json::output_formatting format )
   {
      switch( v.get_type() )
      {
         case variant::null_type:
              os << "null";
              return;
         case variant::int64_type:
         {
              int64_t i = v.as_int64();
              if( format == json::stringify_large_ints_and_doubles &&
                  i > 0xffffffff )
                 os << '"'<<v.as_string()<<'"';
              else
                 os << i;

              return;
         }
         case variant::uint64_type:
         {
              uint64_t i = v.as_uint64();
              if( format == json::stringify_large_ints_and_doubles &&
                  i > 0xffffffff )
                 os << '"'<<v.as_string()<<'"';
              else
                 os << i;

              return;
         }
         case variant::double_type:
              if (format == json::stringify_large_ints_and_doubles)
                 os << '"'<<v.as_string()<<'"';
              else
                 os << v.as_string();
              return;
         case variant::bool_type:
              os << v.as_string();
              return;
         case variant::string_type:
              escape_string( v.get_string(), os );
              return;
         case variant::blob_type:
              escape_string( v.as_string(), os );
              return;
         case variant::array_type:
           {
              const variants&  a = v.get_array();
              to_stream( os, a, format );
              return;
           }
         case variant::object_type:
           {
              const variant_object& o =  v.get_object();
              to_stream(os, o, format );
              return;
           }
      }
   }
Ejemplo n.º 2
0
 void to_stream( T& os, const variant& v, json::output_formatting format, uint32_t max_depth )
 {
    FC_ASSERT( max_depth > 0, "Too many nested objects!" );
    switch( v.get_type() )
    {
       case variant::null_type:
            os << "null";
            return;
       case variant::int64_type:
            if( format == json::stringify_large_ints_and_doubles &&
                ( v.as_int64() > INT32_MAX || v.as_int64() < INT32_MIN ) )
               os << '"'<<v.as_string()<<'"';
            else
               os << v.as_int64();
            return;
       case variant::uint64_type:
            if( format == json::stringify_large_ints_and_doubles &&
                v.as_uint64() > 0xffffffff )
               os << '"'<<v.as_string()<<'"';
            else
               os << v.as_uint64();
            return;
       case variant::double_type:
            if (format == json::stringify_large_ints_and_doubles)
               os << '"'<<v.as_string()<<'"';
            else
               os << v.as_string();
            return;
       case variant::bool_type:
            os << v.as_string();
            return;
       case variant::string_type:
            escape_string( v.get_string(), os );
            return;
       case variant::blob_type:
            escape_string( v.as_string(), os );
            return;
       case variant::array_type:
            to_stream( os, v.get_array(), format, max_depth - 1 );
            return;
       case variant::object_type:
            to_stream(os, v.get_object(), format, max_depth - 1 );
            return;
       default:
          FC_THROW_EXCEPTION( fc::invalid_arg_exception, "Unsupported variant type: ${type}", ( "type", v.get_type() ) );
    }
 }
Ejemplo n.º 3
0
variant::variant( const variant& v )
{
    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;
    default:
        memcpy( this, &v, sizeof(v) );
    }
}
Ejemplo n.º 4
0
////////////////////////////////////////////////////////////////////////////////////////

TEST_CASE("constructor - invoke general", "[constructor]")
{
    type t = type::get<ctor_invoke_test>();
    REQUIRE(t.is_valid() == true);

    SECTION("invoke default ctor")
    {
        constructor ctor = t.get_constructor();
        REQUIRE(ctor.is_valid() == true);

        variant var = ctor.invoke();
        CHECK(var.is_valid() == true);
        CHECK(var.get_type() == type::get<ctor_invoke_test*>());
        ctor_invoke_test* obj = var.get_value<ctor_invoke_test*>();
        CHECK(obj->default_ctor_invoked == true);
        CHECK(t.get_destructor().invoke(var) == true);
    }

    SECTION("invoke copy-ctor")
    {
        constructor ctor = t.get_constructor({type::get<ctor_invoke_test>()});
        REQUIRE(ctor.is_valid() == true);

        variant var = ctor.invoke(12);
        CHECK(var.is_valid() == false);

        ctor_invoke_test obj_default;
        var = ctor.invoke(obj_default);
Ejemplo n.º 5
0
 inline void pack( Stream& s, const variant& v )
 {
    pack( s, uint8_t(v.get_type()) );
    v.visit( variant_packer<Stream>(s) );
 }