Adding multi_index to/from variant support

include/fc/variant.hpp

@@ -15,6 +15,7 @@
 #include <fc/container/deque_fwd.hpp>
 #include <fc/container/flat_fwd.hpp>
 #include <fc/smart_ref_fwd.hpp>
+#include <boost/multi_index_container_fwd.hpp>
 
 namespace fc
 {
@@ -45,6 +46,11 @@ namespace fc
 
    void to_variant( const blob& var,  variant& vo );
    void from_variant( const variant& var,  blob& vo );
+
+
+   template<typename T, typename... Args> void to_variant( const boost::multi_index_container<T,Args...>& s, variant& v );
+   template<typename T, typename... Args> void from_variant( const variant& v, boost::multi_index_container<T,Args...>& s );
+
    template<typename T> void to_variant( const smart_ref<T>& s, variant& v );
    template<typename T> void from_variant( const variant& v, smart_ref<T>& s );
    template<typename T> void to_variant( const safe<T>& s, variant& v );
@@ -464,7 +470,7 @@ namespace fc
       std::vector<variant> vars(t.size());
        for( size_t i = 0; i < t.size(); ++i )
           vars[i] = variant(t[i]);
-       v = vars;
+       v = std::move(vars);
    }
    /** @ingroup Serializable */
    template<typename A, typename B>
@@ -543,6 +549,23 @@ namespace fc
    template<typename T>
    void from_variant( const variant& v, smart_ref<T>& s ) { from_variant( v, *s ); }
 
+   template<typename T, typename... Args> void to_variant( const boost::multi_index_container<T,Args...>& c, variant& v )
+   {
+       std::vector<variant> vars;
+       vars.reserve( c.size() );
+       for( const auto& item : c )
+          vars.emplace_back( variant(item) );
+       v = std::move(vars);
+   }
+
+   template<typename T, typename... Args> void from_variant( const variant& v, boost::multi_index_container<T,Args...>& c )
+   {
+      const variants& vars = v.get_array();
+      c.clear();
+      for( const auto& item : vars )
+         c.insert( item.as<T>() );
+   }
+
    variant operator + ( const variant& a, const variant& b );
    variant operator - ( const variant& a, const variant& b );
    variant operator * ( const variant& a, const variant& b );

tests/blind.cpp

@@ -26,6 +26,14 @@ int main( int argc, char** argv )
       auto OutB2 = fc::ecc::blind_sum( {InB1,InB2,OutB1}, 2 );
       auto OutC2 = fc::ecc::blind( OutB2, 60 );
 
+      /*
+      FC_ASSERT( fc::ecc::verify_sum( {},{InC1,InC2},  100 ) );
+      FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {}, -100 ) );
+      */
+
+      //FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {OutC1}, -60 ) );
+
+
       FC_ASSERT( fc::ecc::verify_sum( {InC1,InC2}, {OutC1,OutC2}, 0 ) );
       auto nonce = fc::sha256::hash("nonce");
 
@@ -54,6 +62,7 @@ int main( int argc, char** argv )
       auto B2m1 = fc::ecc::blind_sum( {B2,B1}, 1 );
       auto C2m1 = fc::ecc::blind( B2m1, 1 );
 
+      FC_ASSERT( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
       FC_ASSERT( fc::ecc::verify_sum( {C1,C2}, {C3}, 0 ) );
       FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
       FC_ASSERT( fc::ecc::verify_sum( {C3}, {C1,C2}, 0 ) );
@@ -63,6 +72,7 @@ int main( int argc, char** argv )
          auto B1 = fc::sha256::hash("B1");
          auto B2 = fc::sha256::hash("B2");
          auto B3 = fc::sha256::hash("B3");
+         auto B4 = fc::sha256::hash("B4");
 
          //secp256k1_scalar_get_b32((unsigned char*)&B1, (const secp256k1_scalar_t*)&B2);
          //B1 = fc::variant("b2e5da56ef9f2a34d3e22fd12634bc99261e95c87b9960bf94ed3d27b30").as<fc::sha256>();
@@ -70,15 +80,30 @@ int main( int argc, char** argv )
          auto C1 = fc::ecc::blind( B1, INT64_MAX );
          auto C2 = fc::ecc::blind( B1, 0 );
          auto C3 = fc::ecc::blind( B1, 1 );
+         auto C4 = fc::ecc::blind( B1, 2 );
 
          FC_ASSERT( fc::ecc::verify_sum( {C2}, {C3}, -1 ) );
          FC_ASSERT( fc::ecc::verify_sum( {C1}, {C1}, 0 ) );
          FC_ASSERT( fc::ecc::verify_sum( {C2}, {C2}, 0 ) );
          FC_ASSERT( fc::ecc::verify_sum( {C3}, {C2}, 1 ) );
          FC_ASSERT( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
+         FC_ASSERT( fc::ecc::verify_sum( {C1}, {C2}, INT64_MAX ) );
          FC_ASSERT( fc::ecc::verify_sum( {C2}, {C1}, -INT64_MAX ) );
+      }
 
 
+      {
+         auto Out1 = fc::sha256::hash("B1");
+         auto Out2 = fc::sha256::hash("B2");
+         auto OutC1 = fc::ecc::blind( Out1, 250 );
+         auto OutC2 = fc::ecc::blind( Out2, 750 );
+         auto InBlind = fc::ecc::blind_sum( {Out1,Out2}, 2 );
+         auto InC  = fc::ecc::blind( InBlind, 1000 );
+         auto In0  = fc::ecc::blind( InBlind, 0 );
+
+         FC_ASSERT( fc::ecc::verify_sum( {InC}, {OutC1,OutC2}, 0 ) );
+         FC_ASSERT( fc::ecc::verify_sum( {InC}, {In0}, 1000 ) );
+
       }