operation_history_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 <graphene/protocol/operations.hpp>
#include <graphene/db/object.hpp>

#include <boost/multi_index/composite_key.hpp>

namespace graphene { namespace chain {

   class operation_history_object : public abstract_object<operation_history_object,
                                              protocol_ids, operation_history_object_type>
   {
      public:
         explicit operation_history_object( const operation& o ):op(o){}
         operation_history_object() = default;
         operation_history_object( const operation& o, uint32_t bn, uint16_t tib, uint16_t oit, uint32_t vo, bool iv,
                                   const time_point_sec& bt )
         : op(o), block_num(bn), trx_in_block(tib), op_in_trx(oit), virtual_op(vo), is_virtual(iv), block_time(bt) {}

         operation         op;
         operation_result  result;
         uint32_t          block_num = 0;
         uint16_t          trx_in_block = 0;
         uint16_t          op_in_trx = 0;
         uint32_t          virtual_op = 0;
         bool              is_virtual = false;
         time_point_sec    block_time;
   };

   class account_history_object :  public abstract_object<account_history_object,
                                             implementation_ids, impl_account_history_object_type>
   {
      public:
         account_id_type                      account; 
         operation_history_id_type            operation_id;
         uint64_t                             sequence = 0; 
         account_history_id_type              next;
   };

   struct by_block;
   struct by_time;

   using operation_history_mlti_idx_type = multi_index_container<
      operation_history_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
         ordered_unique< tag<by_block>,
            composite_key< operation_history_object,
               member< operation_history_object, uint32_t, &operation_history_object::block_num>,
               member< operation_history_object, uint16_t, &operation_history_object::trx_in_block>,
               member< operation_history_object, uint16_t, &operation_history_object::op_in_trx>,
               member< operation_history_object, uint32_t, &operation_history_object::virtual_op>
            >
         >,
         ordered_unique< tag<by_time>,
            composite_key< operation_history_object,
               member< operation_history_object, time_point_sec, &operation_history_object::block_time>,
               member< object, object_id_type, &object::id >
            >,
            composite_key_compare<
               std::greater< time_point_sec >,
               std::greater< object_id_type >
            >
         >
      >
   >;

   using operation_history_index = generic_index< operation_history_object, operation_history_mlti_idx_type >;

   struct by_seq;
   struct by_op;
   struct by_opid;

   using account_history_multi_idx_type = multi_index_container<
      account_history_object,
      indexed_by<
         ordered_unique< tag<by_id>, member< object, object_id_type, &object::id > >,
         ordered_unique< tag<by_seq>,
            composite_key< account_history_object,
               member< account_history_object, account_id_type, &account_history_object::account>,
               member< account_history_object, uint64_t, &account_history_object::sequence>
            >
         >,
         ordered_unique< tag<by_op>,
            composite_key< account_history_object,
               member< account_history_object, account_id_type, &account_history_object::account>,
               member< account_history_object, operation_history_id_type, &account_history_object::operation_id>
            >,
            composite_key_compare<
               std::less< account_id_type >,
               std::greater< operation_history_id_type >
            >
         >,
         ordered_non_unique< tag<by_opid>,
            member< account_history_object, operation_history_id_type, &account_history_object::operation_id>
         >
      >
   >;

   using account_history_index = generic_index< account_history_object, account_history_multi_idx_type >;


} } // graphene::chain

MAP_OBJECT_ID_TO_TYPE(graphene::chain::operation_history_object)
MAP_OBJECT_ID_TO_TYPE(graphene::chain::account_history_object)

FC_REFLECT_TYPENAME( graphene::chain::operation_history_object )
FC_REFLECT_TYPENAME( graphene::chain::account_history_object )

GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::operation_history_object )
GRAPHENE_DECLARE_EXTERNAL_SERIALIZATION( graphene::chain::account_history_object )