object.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
#include <boost/multiprecision/integer.hpp>
#include <graphene/protocol/object_id.hpp>
#include <fc/io/raw.hpp>
#include <fc/crypto/city.hpp>

#define MAX_NESTING (200)

namespace graphene { namespace db {
   class object
   {
      public:
         object() = default;
         object( uint8_t space_id, uint8_t type_id ) : id( space_id, type_id, 0 ) {}
         virtual ~object() = default;

         // serialized
         object_id_type          id;

         virtual std::unique_ptr<object> clone()const = 0;
         virtual void                    move_from( object& obj ) = 0;
         virtual fc::variant             to_variant()const  = 0;
         virtual std::vector<char>       pack()const = 0;
   };

   template<typename DerivedClass>
   class base_abstract_object : public object
   {
      public:
         using object::object; // constructors
         std::unique_ptr<object> clone()const override
         {
            return std::make_unique<DerivedClass>( *static_cast<const DerivedClass*>(this) );
         }

         void    move_from( object& obj ) override
         {
            static_cast<DerivedClass&>(*this) = std::move( static_cast<DerivedClass&>(obj) );
         }
         fc::variant to_variant()const override
         { return fc::variant( static_cast<const DerivedClass&>(*this), MAX_NESTING ); }
         std::vector<char> pack()const override { return fc::raw::pack( static_cast<const DerivedClass&>(*this) ); }
   };

   template<typename DerivedClass, uint8_t SpaceID, uint8_t TypeID>
   class abstract_object : public base_abstract_object<DerivedClass>
   {
   public:
      static constexpr uint8_t space_id = SpaceID;
      static constexpr uint8_t type_id = TypeID;
      abstract_object() : base_abstract_object<DerivedClass>( space_id, type_id ) {}
      object_id<SpaceID,TypeID> get_id() const { return object_id<SpaceID,TypeID>( this->id ); }
   };

   using annotation_map = fc::flat_map<uint8_t, object_id_type>;

   template<typename DerivedClass>
   class annotated_object : public base_abstract_object<DerivedClass>
   {
      public:
         object_id_type          get_annotation( uint8_t annotation_id_space )const
         {
            auto itr = annotations.find(annotation_id_space);
            if( itr != annotations.end() ) return itr->second;
            return object_id_type();
         }
         void                    set_annotation( object_id_type id )
         {
            annotations[id.space()] = id;
         }

         annotation_map annotations;
   };

} } // graphene::db

// Without this, pack(object_id) tries to match the template for
// pack(boost::multiprecision::uint128_t). No idea why. :-(
namespace boost { namespace multiprecision { namespace detail {
template<typename To>
struct is_restricted_conversion<graphene::db::object,To> : public mpl::true_ {};
}}}

FC_REFLECT_TYPENAME( graphene::db::annotation_map )
FC_REFLECT( graphene::db::object, (id) )
FC_REFLECT_DERIVED_TEMPLATE( (typename Derived), graphene::db::annotated_object<Derived>, (graphene::db::object),
                             (annotations) )