variant_object.hpp

Go to the documentation of this file.

#pragma once
#include <fc/variant.hpp>
#include <fc/unique_ptr.hpp>
 
namespace fc
{
   class mutable_variant_object;
 
   class variant_object
   {
   public:
      class entry
      {
      public:
         entry();
         entry( string k, variant v );
         entry( entry&& e );
         entry( const entry& e);
         entry& operator=(const entry&);
         entry& operator=(entry&&);
 
         const string&        key()const;
         const variant& value()const;
         void  set( variant v );
 
         variant&       value();
 
         friend bool operator == (const entry& a, const entry& b) {
            return a._key == b._key && a._value == b._value;
         }
         friend bool operator != (const entry& a, const entry& b) {
            return !(a == b);
         }
 
      private:
         string  _key;
         variant _value;
      };
 
      typedef std::vector< entry >::const_iterator iterator;
 
      iterator begin()const;
      iterator end()const;
      iterator find( const string& key )const;
      iterator find( const char* key )const;
      const variant& operator[]( const string& key )const;
      const variant& operator[]( const char* key )const;
      size_t size()const;
      bool   contains( const char* key ) const { return find(key) != end(); }
 
      variant_object();
 
      variant_object( string key, variant val );
 
      template<typename T>
      variant_object( string key, T&& val )
      :_key_value( std::make_shared<std::vector<entry> >() )
      {
         *this = variant_object( std::move(key), variant(forward<T>(val)) );
      }
      variant_object( const variant_object& );
      variant_object( variant_object&& );
 
      variant_object( const mutable_variant_object& );
      variant_object( mutable_variant_object&& );
 
      variant_object& operator=( variant_object&& );
      variant_object& operator=( const variant_object& );
 
      variant_object& operator=( mutable_variant_object&& );
      variant_object& operator=( const mutable_variant_object& );
 
      size_t estimated_size()const;
 
   private:
      std::shared_ptr< std::vector< entry > > _key_value;
      friend class mutable_variant_object;
   };
   void to_variant( const variant_object& var,  variant& vo );
   void from_variant( const variant& var,  variant_object& vo );
 
 
   class mutable_variant_object
   {
   public:
      typedef variant_object::entry  entry;
 
      typedef std::vector< entry >::iterator       iterator;
      typedef std::vector< entry >::const_iterator const_iterator;
 
      iterator begin()const;
      iterator end()const;
      iterator find( const string& key )const;
      iterator find( const char* key )const;
      const variant& operator[]( const string& key )const;
      const variant& operator[]( const char* key )const;
      size_t size()const;
      variant& operator[]( const string& key );
      variant& operator[]( const char* key );
 
      void                 reserve( size_t s);
      iterator             begin();
      iterator             end();
      void                 erase( const string& key );
      iterator             find( const string& key );
      iterator             find( const char* key );
 
 
      mutable_variant_object& set( string key, variant var ) &;
      mutable_variant_object set( string key, variant var ) &&;
 
      mutable_variant_object& operator()( string key, variant var ) &;
      mutable_variant_object operator()( string key, variant var ) &&;
      template<typename T>
      mutable_variant_object& operator()( string key, T&& var ) &
      {
         set(std::move(key), variant( fc::forward<T>(var) ) );
         return *this;
      }
      template<typename T>
      mutable_variant_object operator()( string key, T&& var ) &&
      {
         set(std::move(key), variant( fc::forward<T>(var) ) );
         return std::move(*this);
      }
      mutable_variant_object& operator()( const variant_object& vo ) &;
      mutable_variant_object operator()( const variant_object& vo ) &&;
      mutable_variant_object& operator()( const mutable_variant_object& mvo ) &;
      mutable_variant_object operator()( const mutable_variant_object& mvo ) &&;
 
 
      template<typename T,
               typename = std::enable_if_t<!std::is_base_of<mutable_variant_object,
                                                            std::decay_t<T>>::value>>
      explicit mutable_variant_object( T&& v )
      :_key_value( new std::vector<entry>() )
      {
          *this = variant(fc::forward<T>(v)).get_object();
      }
 
      mutable_variant_object();
 
      mutable_variant_object( string key, variant val );
      template<typename T>
      mutable_variant_object( string key, T&& val )
      :_key_value( new std::vector<entry>() )
      {
         set( std::move(key), variant(forward<T>(val)) );
      }
 
      mutable_variant_object( mutable_variant_object&& );
      mutable_variant_object( const mutable_variant_object& );
      mutable_variant_object( const variant_object& );
 
      mutable_variant_object& operator=( mutable_variant_object&& );
      mutable_variant_object& operator=( const mutable_variant_object& );
      mutable_variant_object& operator=( const variant_object& );
   private:
      std::unique_ptr< std::vector< entry > > _key_value;
      friend class variant_object;
   };
   void to_variant( const mutable_variant_object& var,  variant& vo );
   void from_variant( const variant& var,  mutable_variant_object& vo );
 
} // namespace fc