variant_object.hpp

Go to the documentation of this file.

#pragma once
#include <fc/variant.hpp>
#include <memory>
 
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();
             
      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(std::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& );
 
   private:
      std::shared_ptr< std::vector< entry > > _key_value;
      friend class mutable_variant_object;
   };
   void to_variant( const variant_object& var, variant& vo, uint32_t max_depth = 1 );
   void from_variant( const variant& var, variant_object& vo, uint32_t max_depth = 1 );
 
 
   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& operator()( string key, variant var, uint32_t max_depth = 1 );
      template<typename T>
      mutable_variant_object& operator()( string key, T&& var, uint32_t max_depth )
      {
         _FC_ASSERT( max_depth > 0, "Recursion depth exceeded!" );
         set( std::move(key), variant( std::forward<T>(var), max_depth - 1 ) );
         return *this;
      }
      mutable_variant_object& operator()( const variant_object& vo );
      mutable_variant_object& operator()( const mutable_variant_object& mvo );
 
 
      template<typename T>
      explicit mutable_variant_object( T&& v )
      :_key_value( new std::vector<entry>() )
      {
          *this = variant(std::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(std::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;
   };
 
   class limited_mutable_variant_object : public mutable_variant_object
   {
      public:
         limited_mutable_variant_object( uint32_t max_depth, bool skip_on_exception = false );
 
         template<typename T>
         limited_mutable_variant_object& operator()( string key, T&& var )
         {
            if( _reached_depth_limit )
               // _skip_on_exception will always be true here
               return *this;
 
            optional<variant> v;
            try
            {
               v = variant( std::forward<T>(var), _max_depth );
            }
            catch( ... )
            {
               if( !_skip_on_exception )
                  throw;
               v = variant( "[ERROR: Caught exception while converting data to variant]" );
            }
            set( std::move(key), *v );
            return *this;
         }
         limited_mutable_variant_object& operator()( const variant_object& vo );
 
      private:
         const uint32_t _max_depth;       
         const bool _reached_depth_limit; 
         const bool _skip_on_exception;   
   };
 
   void to_variant( const mutable_variant_object& var, variant& vo, uint32_t max_depth = 1 );
   void from_variant( const variant& var, mutable_variant_object& vo, uint32_t max_depth = 1 );
 
} // namespace fc