porting json/variant fixes from bitshares #3539

EOSIO · May 30, 2018 · 2f47262 · 2f47262
1 parent f86a4b5
commit 2f47262
Show file tree

Hide file tree

Showing 20 changed files with 56 additions and 54 deletions.
diff --git a/libraries/fc/include/fc/array.hpp b/libraries/fc/include/fc/array.hpp
@@ -102,14 +102,14 @@ namespace fc {
   { return 0 != memcmp( a.data, b.data, N*sizeof(T) ); }
 
   template<typename T, size_t N>
-  void to_variant( const array<T,N>& bi, variant& v )
+  void to_variant( const array<T,N>& bi, variant& v, uint32_t )
   {
      v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
   template<typename T, size_t N>
-  void from_variant( const variant& v, array<T,N>& bi )
+  void from_variant( const variant& v, array<T,N>& bi, uint32_t )
   {
-    std::vector<char> ve = v.as< std::vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >( 1 );
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );

diff --git a/libraries/fc/include/fc/crypto/bigint.hpp b/libraries/fc/include/fc/crypto/bigint.hpp
@@ -69,8 +69,8 @@ namespace fc {
 
   class variant;
   /** encodes the big int as base64 string, or a number */
-  void to_variant( const bigint& bi, variant& v );
+  void to_variant( const bigint& bi, variant& v, uint32_t max_depth = 1 );
   /** decodes the big int as base64 string, or a number */
-  void from_variant( const variant& v, bigint& bi );
+  void from_variant( const variant& v, bigint& bi, uint32_t max_depth = 1 );
 } // namespace fc
 
diff --git a/libraries/fc/include/fc/crypto/ripemd160.hpp b/libraries/fc/include/fc/crypto/ripemd160.hpp
@@ -72,8 +72,8 @@ class ripemd160
 };
 
   class variant;
-  void to_variant( const ripemd160& bi, variant& v );
-  void from_variant( const variant& v, ripemd160& bi );
+  void to_variant( const ripemd160& bi, variant& v, uint32_t max_depth );
+  void from_variant( const variant& v, ripemd160& bi, uint32_t max_depth );
 
   typedef ripemd160 uint160_t;
   typedef ripemd160 uint160;

diff --git a/libraries/fc/include/fc/crypto/sha256.hpp b/libraries/fc/include/fc/crypto/sha256.hpp
@@ -101,8 +101,8 @@ class sha256
   typedef sha256 uint256;
 
   class variant;
-  void to_variant( const sha256& bi, variant& v );
-  void from_variant( const variant& v, sha256& bi );
+  void to_variant( const sha256& bi, variant& v, uint32_t max_depth );
+  void from_variant( const variant& v, sha256& bi, uint32_t max_depth );
 
   uint64_t hash64(const char* buf, size_t len);    
 

diff --git a/libraries/fc/include/fc/crypto/sha512.hpp b/libraries/fc/include/fc/crypto/sha512.hpp
@@ -69,8 +69,8 @@ class sha512
   typedef fc::sha512 uint512;
 
   class variant;
-  void to_variant( const sha512& bi, variant& v );
-  void from_variant( const variant& v, sha512& bi );
+  void to_variant( const sha512& bi, variant& v, uint32_t max_depth );
+  void from_variant( const variant& v, sha512& bi, uint32_t max_depth );
 
 } // fc
 

diff --git a/libraries/fc/include/fc/io/varint.hpp b/libraries/fc/include/fc/io/varint.hpp
@@ -70,10 +70,10 @@ struct signed_int {
 
 class variant;
 
-void to_variant( const signed_int& var,  variant& vo );
-void from_variant( const variant& var,  signed_int& vo );
-void to_variant( const unsigned_int& var,  variant& vo );
-void from_variant( const variant& var,  unsigned_int& vo );
+void to_variant( const signed_int& var,  variant& vo, uint32_t max_depth = 1 );
+void from_variant( const variant& var,  signed_int& vo, uint32_t max_depth = 1 );
+void to_variant( const unsigned_int& var,  variant& vo, uint32_t max_depth = 1 );
+void from_variant( const variant& var,  unsigned_int& vo, uint32_t max_depth = 1 );
 
 }  // namespace fc
 

diff --git a/libraries/fc/include/fc/real128.hpp b/libraries/fc/include/fc/real128.hpp
@@ -36,8 +36,8 @@ namespace fc {
          uint128  fixed;
    };
 
-   void to_variant( const real128& var,  variant& vo );
-   void from_variant( const variant& var,  real128& vo );
+   void to_variant( const real128& var,  variant& vo, uint32_t max_depth = 1 );
+   void from_variant( const variant& var,  real128& vo, uint32_t max_depth = 1 );
 
   namespace raw  
   {

diff --git a/libraries/fc/include/fc/static_variant.hpp b/libraries/fc/include/fc/static_variant.hpp
@@ -372,42 +372,44 @@ struct visitor {
    struct from_static_variant 
    {
       variant& var;
-      from_static_variant( variant& dv ):var(dv){}
+      const uint32_t _max_depth;
+      from_static_variant( variant& dv, uint32_t max_depth ):var(dv),_max_depth(max_depth){}
 
       typedef void result_type;
       template<typename T> void operator()( const T& v )const
       {
-         to_variant( v, var );
+         to_variant( v, var, _max_depth );
       }
    };
 
    struct to_static_variant
    {
       const variant& var;
-      to_static_variant( const variant& dv ):var(dv){}
+      const uint32_t _max_depth;
+      to_static_variant( const variant& dv, uint32_t max_depth ):var(dv),_max_depth(max_depth){}
 
       typedef void result_type;
       template<typename T> void operator()( T& v )const
       {
-         from_variant( var, v ); 
+         from_variant( var, v, _max_depth ); 
       }
    };
 
 
-   template<typename... T> void to_variant( const fc::static_variant<T...>& s, fc::variant& v )
+   template<typename... T> void to_variant( const fc::static_variant<T...>& s, fc::variant& v, uint32_t max_depth )
    {
       variant tmp;
       variants vars(2);
       vars[0] = s.which();
-      s.visit( from_static_variant(vars[1]) );
+      s.visit( from_static_variant(vars[1], max_depth - 1) );
       v = std::move(vars);
    }
-   template<typename... T> void from_variant( const fc::variant& v, fc::static_variant<T...>& s )
+   template<typename... T> void from_variant( const fc::variant& v, fc::static_variant<T...>& s, uint32_t max_depth )
    {
       auto ar = v.get_array();
       if( ar.size() < 2 ) return;
       s.set_which( ar[0].as_uint64() );
-      s.visit( to_static_variant(ar[1]) );
+      s.visit( to_static_variant(ar[1], max_depth - 1) );
    }
 
   template<typename... T> struct get_typename { static const char* name()   { return BOOST_CORE_TYPEID(static_variant<T...>).name();   } };

diff --git a/libraries/fc/include/fc/time.hpp b/libraries/fc/include/fc/time.hpp
@@ -38,8 +38,8 @@ namespace fc {
   inline microseconds days(int64_t d) { return hours(24*d); }
 
   class variant;
-  void to_variant( const fc::microseconds&,  fc::variant&  );
-  void from_variant( const fc::variant& , fc::microseconds& );
+  void to_variant( const fc::microseconds&,  fc::variant&, uint32_t max_depth = 1  );
+  void from_variant( const fc::variant& , fc::microseconds&, uint32_t max_depth = 1 );
 
   class time_point {
     public:

diff --git a/libraries/fc/include/fc/uint128.hpp b/libraries/fc/include/fc/uint128.hpp
@@ -127,8 +127,8 @@ namespace fc
 
   class variant;
 
-  void to_variant( const uint128& var,  variant& vo );
-  void from_variant( const variant& var,  uint128& vo );
+  void to_variant( const uint128& var,  variant& vo, uint32_t max_depth = 1 );
+  void from_variant( const variant& var,  uint128& vo, uint32_t max_depth = 1 );
 //  void to_variant( const unsigned __int128& var,  variant& vo );
 //  void from_variant( const variant& var,  unsigned __int128& vo );
 

diff --git a/libraries/fc/include/fc/variant.hpp b/libraries/fc/include/fc/variant.hpp
@@ -189,7 +189,7 @@ namespace fc
    template<typename A, typename B>
    void to_variant( const std::pair<A,B>& t, variant& v, uint32_t max_depth );
    template<typename A, typename B>
-   void from_variant( const variant& v, std::pair<A,B>& p );
+   void from_variant( const variant& v, std::pair<A,B>& p, uint32_t max_depth );
 
 
 
@@ -371,7 +371,7 @@ namespace fc
         }
 
         template<typename T>
-        explicit variant( const T& val, uint32_t max_depth );
+        explicit variant( const T& val, uint32_t max_depth = 1 /*XXX no default in bitshares */ );
 
 
         void    clear();

diff --git a/libraries/fc/src/crypto/bigint.cpp b/libraries/fc/src/crypto/bigint.cpp
@@ -208,16 +208,16 @@ namespace fc {
       }
 
   /** encodes the big int as base64 string, or a number */
-  void to_variant( const bigint& bi, variant& v )
+  void to_variant( const bigint& bi, variant& v, uint32_t )
   {
     std::vector<char> ve = bi;
     v = fc::variant(base64_encode((unsigned char*)ve.data(),ve.size()));
   }
 
   /** decodes the big int as base64 string, or a number */
-  void from_variant( const variant& v, bigint& bi )
+  void from_variant( const variant& v, bigint& bi, uint32_t )
   {
-    if( v.is_numeric() ) bi = bigint( static_cast<unsigned long>(v.as_uint64()) );
+    if( v.is_numeric() ) bi = bigint( static_cast<unsigned long>(v.as_uint64( )) );
     else
     {
         std::string b64 = v.as_string();

diff --git a/libraries/fc/src/crypto/ripemd160.cpp b/libraries/fc/src/crypto/ripemd160.cpp
@@ -98,13 +98,13 @@ bool operator == ( const ripemd160& h1, const ripemd160& h2 ) {
   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
 }
 
-  void to_variant( const ripemd160& bi, variant& v )
+  void to_variant( const ripemd160& bi, variant& v, uint32_t )
   {
      v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
-  void from_variant( const variant& v, ripemd160& bi )
+  void from_variant( const variant& v, ripemd160& bi, uint32_t max_depth )
   {
-    std::vector<char> ve = v.as< std::vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >( max_depth );
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );

diff --git a/libraries/fc/src/crypto/sha256.cpp b/libraries/fc/src/crypto/sha256.cpp
@@ -194,13 +194,13 @@ namespace fc {
       return lzbits;
    }
 
-  void to_variant( const sha256& bi, variant& v )
+  void to_variant( const sha256& bi, variant& v, uint32_t max_depth )
   {
      v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
-  void from_variant( const variant& v, sha256& bi )
+  void from_variant( const variant& v, sha256& bi, uint32_t max_depth )
   {
-    std::vector<char> ve = v.as< std::vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >( max_depth );
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );

diff --git a/libraries/fc/src/crypto/sha512.cpp b/libraries/fc/src/crypto/sha512.cpp
@@ -85,13 +85,13 @@ namespace fc {
       return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
     }
 
-  void to_variant( const sha512& bi, variant& v )
+  void to_variant( const sha512& bi, variant& v, uint32_t )
   {
      v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
-  void from_variant( const variant& v, sha512& bi )
+  void from_variant( const variant& v, sha512& bi, uint32_t max_depth )
   {
-    std::vector<char> ve = v.as< std::vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >( max_depth );
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );

diff --git a/libraries/fc/src/io/varint.cpp b/libraries/fc/src/io/varint.cpp
@@ -3,8 +3,8 @@
 
 namespace fc
 {
-void to_variant( const signed_int& var,  variant& vo ) { vo = var.value; }
-void from_variant( const variant& var,  signed_int& vo ) { vo.value = static_cast<int32_t>(var.as_int64()); }
-void to_variant( const unsigned_int& var, variant& vo )  { vo = var.value; }
-void from_variant( const variant& var,  unsigned_int& vo )  { vo.value = static_cast<uint32_t>(var.as_uint64()); }
+void to_variant( const signed_int& var,  variant& vo, uint32_t ) { vo = var.value; }
+void from_variant( const variant& var,  signed_int& vo, uint32_t ) { vo.value = static_cast<int32_t>(var.as_int64()); }
+void to_variant( const unsigned_int& var, variant& vo, uint32_t )  { vo = var.value; }
+void from_variant( const variant& var,  unsigned_int& vo, uint32_t )  { vo.value = static_cast<uint32_t>(var.as_uint64()); }
 }
diff --git a/libraries/fc/src/real128.cpp b/libraries/fc/src/real128.cpp
@@ -118,11 +118,11 @@ namespace fc
        return result;
    }
 
-   void to_variant( const real128& var,  variant& vo )
+   void to_variant( const real128& var,  variant& vo, uint32_t )
    {
       vo = std::string(var);
    }
-   void from_variant( const variant& var,  real128& vo )
+   void from_variant( const variant& var,  real128& vo, uint32_t  )
    {
      vo = real128(var.as_string());
    }

diff --git a/libraries/fc/src/time.cpp b/libraries/fc/src/time.cpp
@@ -143,11 +143,11 @@ namespace fc {
     return get_approximate_relative_time_string(time_point_sec(event_time), time_point_sec(relative_to_time), ago);
   }
 
-  void to_variant( const microseconds& input_microseconds,  variant& output_variant )
+  void to_variant( const microseconds& input_microseconds,  variant& output_variant, uint32_t )
   {
     output_variant = input_microseconds.count();
   }
-  void from_variant( const variant& input_variant,  microseconds& output_microseconds )
+  void from_variant( const variant& input_variant,  microseconds& output_microseconds, uint32_t )
   {
     output_microseconds = microseconds(input_variant.as_int64());
   }

diff --git a/libraries/fc/src/uint128.cpp b/libraries/fc/src/uint128.cpp
@@ -374,8 +374,8 @@ namespace fc
       return _popcount_64( lo ) + _popcount_64( hi );
    }
 
-   void to_variant( const uint128& var,  variant& vo )  { vo = std::string(var);         }
-   void from_variant( const variant& var,  uint128& vo ){ vo = uint128(var.as_string()); }
+   void to_variant( const uint128& var,  variant& vo, uint32_t )  { vo = std::string(var);         }
+   void from_variant( const variant& var,  uint128& vo, uint32_t ){ vo = uint128(var.as_string()); }
 /*
    void to_variant( const unsigned __int128& var,  variant& vo ) { to_variant( uint128(var), vo); }
    void from_variant( const variant& var,  unsigned __int128& vo ) {

diff --git a/libraries/fc/src/variant_object.cpp b/libraries/fc/src/variant_object.cpp
@@ -345,7 +345,7 @@ namespace fc
    /** Appends \a key and \a var without checking for duplicates, designed to
     *  simplify construction of dictionaries using (key,val)(key2,val2) syntax 
     */
-   mutable_variant_object& mutable_variant_object::operator()( string key, variant var )
+   mutable_variant_object& mutable_variant_object::operator()( string key, variant var, uint32_t )
    {
       _key_value->push_back( entry( fc::move(key), fc::move(var) ) );
       return *this;