EncodedBlob.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/nodestore/NodeObject.h>
 
#include <boost/align/align_up.hpp>
 
#include <algorithm>
#include <array>
#include <cstdint>
 
namespace xrpl {
namespace NodeStore {
 
class EncodedBlob
{
    std::array<std::uint8_t, 32> key_{};
 
    std::array<std::uint8_t, boost::alignment::align_up(9 + 1024, alignof(std::uint32_t))>
        payload_{};
 
    std::uint32_t size_;
 
    std::uint8_t* const ptr_;
 
public:
    explicit EncodedBlob(std::shared_ptr<NodeObject> const& obj)
        : size_([&obj]() {
            XRPL_ASSERT(obj, "xrpl::NodeStore::EncodedBlob::EncodedBlob : non-null input");
 
            if (!obj)
                throw std::runtime_error("EncodedBlob: unseated std::shared_ptr used.");
 
            return obj->getData().size() + 9;
        }())
        , ptr_((size_ <= payload_.size()) ? payload_.data() : new std::uint8_t[size_])
    {
        std::fill_n(ptr_, 8, std::uint8_t{0});
        ptr_[8] = static_cast<std::uint8_t>(obj->getType());
        std::copy_n(obj->getData().data(), obj->getData().size(), ptr_ + 9);
        std::copy_n(obj->getHash().data(), obj->getHash().size(), key_.data());
    }
 
    ~EncodedBlob()
    {
        XRPL_ASSERT(
            ((ptr_ == payload_.data()) && (size_ <= payload_.size())) ||
                ((ptr_ != payload_.data()) && (size_ > payload_.size())),
            "xrpl::NodeStore::EncodedBlob::~EncodedBlob : valid payload "
            "pointer");
 
        if (ptr_ != payload_.data())
            delete[] ptr_;
    }
 
    [[nodiscard]] void const*
    getKey() const noexcept
    {
        return static_cast<void const*>(key_.data());
    }
 
    [[nodiscard]] std::size_t
    getSize() const noexcept
    {
        return size_;
    }
 
    [[nodiscard]] void const*
    getData() const noexcept
    {
        return static_cast<void const*>(ptr_);
    }
};
 
}  // namespace NodeStore
}  // namespace xrpl