polkadot_trie.hpp

Go to the documentation of this file.

#ifndef KAGOME_STORAGE_TRIE_POLKADOT_TRIE_HPP
#define KAGOME_STORAGE_TRIE_POLKADOT_TRIE_HPP

#include "storage/buffer_map_types.hpp"

#include "storage/trie/polkadot_trie/polkadot_trie_cursor.hpp"
#include "storage/trie/polkadot_trie/trie_node.hpp"

namespace kagome::storage::trie {

  class PolkadotTrie
      : public face::
            ReadOnlyMap<common::Buffer, common::Buffer, common::BufferView>,
        public face::Writeable<common::BufferView, common::Buffer> {
   public:
    using NodePtr = std::shared_ptr<TrieNode>;
    using ConstNodePtr = std::shared_ptr<const TrieNode>;
    using BranchPtr = std::shared_ptr<BranchNode>;
    using ConstBranchPtr = std::shared_ptr<const BranchNode>;
    using NodeRetrieveFunctor = std::function<outcome::result<NodePtr>(
        std::shared_ptr<OpaqueTrieNode> const &)>;

    using OnDetachCallback = std::function<outcome::result<void>(
        const common::BufferView &key, std::optional<common::Buffer> &&value)>;

    virtual outcome::result<std::tuple<bool, uint32_t>> clearPrefix(
        const common::BufferView &prefix,
        std::optional<uint64_t> limit,
        const OnDetachCallback &callback) = 0;

    virtual NodePtr getRoot() = 0;
    virtual ConstNodePtr getRoot() const = 0;

    virtual outcome::result<ConstNodePtr> retrieveChild(
        const BranchNode &parent, uint8_t idx) const = 0;
    virtual outcome::result<NodePtr> retrieveChild(const BranchNode &parent,
                                                   uint8_t idx) = 0;

    virtual outcome::result<NodePtr> getNode(
        ConstNodePtr parent, const NibblesView &key_nibbles) = 0;
    virtual outcome::result<ConstNodePtr> getNode(
        ConstNodePtr parent, const NibblesView &key_nibbles) const = 0;

    virtual outcome::result<void> forNodeInPath(
        ConstNodePtr parent,
        const NibblesView &path,
        const std::function<outcome::result<void>(
            BranchNode const &, uint8_t idx)> &callback) const = 0;

    virtual std::unique_ptr<PolkadotTrieCursor> trieCursor() = 0;

    std::unique_ptr<Cursor> cursor() final {
      return trieCursor();
    }

    inline static outcome::result<NodePtr> defaultNodeRetrieveFunctor(
        const std::shared_ptr<OpaqueTrieNode> &node) {
      BOOST_ASSERT_MSG(
          node == nullptr
              or std::dynamic_pointer_cast<TrieNode>(node) != nullptr,
          "Unexpected Dummy node.");
      return std::dynamic_pointer_cast<TrieNode>(node);
    }
  };

}  // namespace kagome::storage::trie

#endif  // KAGOME_STORAGE_TRIE_POLKADOT_TRIE_HPP