fork_database.hpp

Go to the documentation of this file.

#pragma once
#include <scorum/protocol/block.hpp>
 
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
 
namespace scorum {
namespace chain {
using boost::multi_index_container;
using namespace boost::multi_index;
 
using scorum::protocol::signed_block;
using scorum::protocol::block_id_type;
 
struct fork_item
{
    fork_item(signed_block d)
        : num(d.block_num())
        , id(d.id())
        , data(std::move(d))
    {
    }
 
    block_id_type previous_id() const
    {
        return data.previous;
    }
 
    std::weak_ptr<fork_item> prev;
    uint32_t num; // initialized in ctor
    bool invalid = false;
    block_id_type id;
    signed_block data;
};
typedef std::shared_ptr<fork_item> item_ptr;
 
class fork_database
{
public:
    typedef std::vector<item_ptr> branch_type;
    const static int MAX_BLOCK_REORDERING = 1024;
 
    fork_database();
    void reset();
 
    void start_block(signed_block b);
    void remove(block_id_type b);
    void set_head(std::shared_ptr<fork_item> h);
    bool is_known_block(const block_id_type& id) const;
    std::shared_ptr<fork_item> fetch_block(const block_id_type& id) const;
    std::vector<item_ptr> fetch_block_by_number(uint32_t n) const;
 
    std::shared_ptr<fork_item> push_block(const signed_block& b);
    std::shared_ptr<fork_item> head() const
    {
        return _head;
    }
    void pop_block();
 
    std::pair<branch_type, branch_type> fetch_branch_from(block_id_type first, block_id_type second) const;
    std::shared_ptr<fork_item> walk_main_branch_to_num(uint32_t block_num) const;
    std::shared_ptr<fork_item> fetch_block_on_main_branch_by_number(uint32_t block_num) const;
 
    struct block_id;
    struct block_num;
    struct by_previous;
    typedef multi_index_container<item_ptr,
                                  indexed_by<hashed_unique<tag<block_id>,
                                                           member<fork_item, block_id_type, &fork_item::id>,
                                                           std::hash<fc::ripemd160>>,
                                             hashed_non_unique<tag<by_previous>,
                                                               const_mem_fun<fork_item,
                                                                             block_id_type,
                                                                             &fork_item::previous_id>,
                                                               std::hash<fc::ripemd160>>,
                                             ordered_non_unique<tag<block_num>,
                                                                member<fork_item, uint32_t, &fork_item::num>>>>
        fork_multi_index_type;
 
    void set_max_size(uint32_t s);
 
private:
    void _push_block(const item_ptr& b);
    void _push_next(const item_ptr& newly_inserted);
 
    uint32_t _max_size = 1024;
 
    fork_multi_index_type _unlinked_index;
    fork_multi_index_type _index;
    std::shared_ptr<fork_item> _head;
};
 
} // namespace chain
} // namespace scorum