supergenius_codec.hpp¶

Namespaces¶

Name
sgns
sgns::storage
sgns::storage::trie

Classes¶

	Name
class	sgns::storage::trie::SuperGeniusCodec

Functions¶

	Name
	OUTCOME_HPP_DECLARE_ERROR_2(sgns::storage::trie , SuperGeniusCodec::Error )

Functions Documentation¶

function OUTCOME_HPP_DECLARE_ERROR_2¶

OUTCOME_HPP_DECLARE_ERROR_2(
    sgns::storage::trie ,
    SuperGeniusCodec::Error 
)

Source code¶

#ifndef SUPERGENIUS_TRIE_SUPERGENIUS_CODEC_IMPL_HPP
#define SUPERGENIUS_TRIE_SUPERGENIUS_CODEC_IMPL_HPP

#include <memory>
#include <string>

#include "storage/trie/serialization/buffer_stream.hpp"
#include "storage/trie/codec.hpp"
#include "storage/trie/supergenius_trie/supergenius_node.hpp"

namespace sgns::storage::trie {

  class SuperGeniusCodec : public Codec {
   public:
    using Buffer = sgns::base::Buffer;

    enum class Error {
      SUCCESS = 0,
      TOO_MANY_NIBBLES,   
      UNKNOWN_NODE_TYPE,  
      INPUT_TOO_SMALL,    
      NO_NODE_VALUE       
    };

    ~SuperGeniusCodec() override = default;

    outcome::result<Buffer> encodeNode(const Node &node) const override;

    outcome::result<std::shared_ptr<Node>> decodeNode(
        const base::Buffer &encoded_data) const override;

    base::Buffer merkleValue(const Buffer &buf) const override;

    base::Hash256 hash256(const Buffer &buf) const override;

    std::string GetName() override
    {
      return "SuperGeniusCodec";
    }

    static KeyNibbles keyToNibbles(const Buffer &key);

    static Buffer nibblesToKey(const KeyNibbles &nibbles);

    outcome::result<Buffer> encodeHeader(const SuperGeniusNode &node) const;

   private:
    outcome::result<Buffer> encodeBranch(const BranchNode &node) const;
    outcome::result<Buffer> encodeLeaf(const LeafNode &node) const;

    outcome::result<std::pair<SuperGeniusNode::Type, size_t>> decodeHeader(
        BufferStream &stream) const;

    outcome::result<KeyNibbles> decodePartialKey(size_t nibbles_num,
                                             BufferStream &stream) const;

    outcome::result<std::shared_ptr<Node>> decodeBranch(
        SuperGeniusNode::Type type,
        const KeyNibbles &partial_key,
        BufferStream &stream) const;
  };

}  // namespace sgns::storage::trie

OUTCOME_HPP_DECLARE_ERROR_2(sgns::storage::trie, SuperGeniusCodec::Error);

#endif  // SUPERGENIUS_TRIE_SUPERGENIUS_CODEC_IMPL_HPP

Updated on 2026-03-04 at 13:10:45 -0800