RawStateTable.cpp

#include <xrpl/ledger/detail/RawStateTable.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/RawView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <memory>
#include <optional>
#include <stdexcept>
#include <tuple>
#include <utility>
 
namespace xrpl::detail {
 
class RawStateTable::SlesIterImpl : public ReadView::SlesType::iter_base
{
private:
    SLE::const_pointer sle0_;
    ReadView::SlesType::Iterator iter0_;
    ReadView::SlesType::Iterator end0_;
    SLE::const_pointer sle1_;
    items_t::const_iterator iter1_;
    items_t::const_iterator end1_;
 
public:
    SlesIterImpl(SlesIterImpl const&) = default;
 
    SlesIterImpl(
        items_t::const_iterator iter1,
        items_t::const_iterator end1,
        ReadView::SlesType::Iterator iter0,
        ReadView::SlesType::Iterator end0)
        : iter0_(std::move(iter0)), end0_(std::move(end0)), iter1_(iter1), end1_(end1)
    {
        if (iter0_ != end0_)
            sle0_ = *iter0_;
        if (iter1_ != end1)
        {
            sle1_ = iter1_->second.sle;
            skip();
        }
    }
 
    std::unique_ptr<base_type>
    copy() const override
    {
        return std::make_unique<SlesIterImpl>(*this);
    }
 
    bool
    equal(base_type const& impl) const override
    {
        if (auto const p = dynamic_cast<SlesIterImpl const*>(&impl))
        {
            XRPL_ASSERT(
                end1_ == p->end1_ && end0_ == p->end0_,
                "xrpl::detail::RawStateTable::equal : matching end "
                "iterators");
            return iter1_ == p->iter1_ && iter0_ == p->iter0_;
        }
 
        return false;
    }
 
    void
    increment() override
    {
        XRPL_ASSERT(
            sle1_ || sle0_,
            "xrpl::detail::RawStateTable::increment : either SLE is "
            "non-null");
 
        if (sle1_ && !sle0_)
        {
            inc1();
            return;
        }
 
        if (sle0_ && !sle1_)
        {
            inc0();
            return;
        }
 
        if (sle1_->key() == sle0_->key())
        {
            inc1();
            inc0();
        }
        else if (sle1_->key() < sle0_->key())
        {
            inc1();
        }
        else
        {
            inc0();
        }
        skip();
    }
 
    value_type
    dereference() const override
    {
        if (!sle1_)
        {
            return sle0_;
        }
        if (!sle0_)
        {
            return sle1_;
        }
        if (sle1_->key() <= sle0_->key())
            return sle1_;
        return sle0_;
    }
 
private:
    void
    inc0()
    {
        ++iter0_;
        if (iter0_ == end0_)
        {
            sle0_ = nullptr;
        }
        else
        {
            sle0_ = *iter0_;
        }
    }
 
    void
    inc1()
    {
        ++iter1_;
        if (iter1_ == end1_)
        {
            sle1_ = nullptr;
        }
        else
        {
            sle1_ = iter1_->second.sle;
        }
    }
 
    void
    skip()
    {
        while (iter1_ != end1_ && iter1_->second.action == Action::Erase &&
               sle0_->key() == sle1_->key())
        {
            inc1();
            inc0();
            if (!sle0_)
                return;
        }
    }
};
 
//------------------------------------------------------------------------------
 
// Base invariants are checked by the base during apply()
 
void
RawStateTable::apply(RawView& to) const
{
    to.rawDestroyXRP(dropsDestroyed_);
    for (auto const& elem : items_)
    {
        auto const& item = elem.second;
        switch (item.action)
        {
            case Action::Erase:
                to.rawErase(item.sle);
                break;
            case Action::Insert:
                to.rawInsert(item.sle);
                break;
            case Action::Replace:
                to.rawReplace(item.sle);
                break;
        }
    }
}
 
bool
RawStateTable::exists(ReadView const& base, Keylet const& k) const
{
    XRPL_ASSERT(k.key.isNonZero(), "xrpl::detail::RawStateTable::exists : nonzero key");
    auto const iter = items_.find(k.key);
    if (iter == items_.end())
        return base.exists(k);
    auto const& item = iter->second;
    if (item.action == Action::Erase)
        return false;
    if (!k.check(*item.sle))
        return false;
    return true;
}
 
/*  This works by first calculating succ() on the parent,
    then calculating succ() our internal list, and taking
    the lower of the two.
*/
auto
RawStateTable::succ(ReadView const& base, key_type const& key, std::optional<key_type> const& last)
    const -> std::optional<key_type>
{
    std::optional<key_type> next = key;
    items_t::const_iterator iter;
    // Find base successor that is
    // not also deleted in our list
    do
    {
        next = base.succ(*next, last);
        if (!next)
            break;
        iter = items_.find(*next);
    } while (iter != items_.end() && iter->second.action == Action::Erase);
    // Find non-deleted successor in our list
    for (iter = items_.upper_bound(key); iter != items_.end(); ++iter)
    {
        if (iter->second.action != Action::Erase)
        {
            // Found both, return the lower key
            if (!next || next > iter->first)
                next = iter->first;
            break;
        }
    }
    // Nothing in our list, return
    // what we got from the parent.
    if (last && next >= last)
        return std::nullopt;
    return next;
}
 
void
RawStateTable::erase(SLE::ref sle)
{
    // The base invariant is checked during apply
    auto const result = items_.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(sle->key()),
        std::forward_as_tuple(Action::Erase, sle));
    if (result.second)
        return;
    auto& item = result.first->second;
    switch (item.action)
    {
        case Action::Erase:
            Throw<std::logic_error>("RawStateTable::erase: already erased");
            break;
        case Action::Insert:
            items_.erase(result.first);
            break;
        case Action::Replace:
            item.action = Action::Erase;
            item.sle = sle;
            break;
    }
}
 
void
RawStateTable::insert(SLE::ref sle)
{
    auto const result = items_.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(sle->key()),
        std::forward_as_tuple(Action::Insert, sle));
    if (result.second)
        return;
    auto& item = result.first->second;
    switch (item.action)
    {
        case Action::Erase:
            item.action = Action::Replace;
            item.sle = sle;
            break;
        case Action::Insert:
            Throw<std::logic_error>("RawStateTable::insert: already inserted");
            break;
        case Action::Replace:
            Throw<std::logic_error>("RawStateTable::insert: already exists");
            break;
    }
}
 
void
RawStateTable::replace(SLE::ref sle)
{
    auto const result = items_.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(sle->key()),
        std::forward_as_tuple(Action::Replace, sle));
    if (result.second)
        return;
    auto& item = result.first->second;
    switch (item.action)
    {
        case Action::Erase:
            Throw<std::logic_error>("RawStateTable::replace: was erased");
            break;
        case Action::Insert:
        case Action::Replace:
            item.sle = sle;
            break;
    }
}
 
SLE::const_pointer
RawStateTable::read(ReadView const& base, Keylet const& k) const
{
    auto const iter = items_.find(k.key);
    if (iter == items_.end())
        return base.read(k);
    auto const& item = iter->second;
    if (item.action == Action::Erase)
        return nullptr;
    // Convert to SLE const
    SLE::const_pointer sle = item.sle;
    if (!k.check(*sle))
        return nullptr;
    return sle;
}
 
void
RawStateTable::destroyXRP(XRPAmount const& fee)
{
    dropsDestroyed_ += fee;
}
 
std::unique_ptr<ReadView::SlesType::iter_base>
RawStateTable::slesBegin(ReadView const& base) const
{
    return std::make_unique<SlesIterImpl>(
        items_.begin(), items_.end(), base.sles.begin(), base.sles.end());
}
 
std::unique_ptr<ReadView::SlesType::iter_base>
RawStateTable::slesEnd(ReadView const& base) const
{
    return std::make_unique<SlesIterImpl>(
        items_.end(), items_.end(), base.sles.end(), base.sles.end());
}
 
std::unique_ptr<ReadView::SlesType::iter_base>
RawStateTable::slesUpperBound(ReadView const& base, uint256 const& key) const
{
    return std::make_unique<SlesIterImpl>(
        items_.upper_bound(key), items_.end(), base.sles.upperBound(key), base.sles.end());
}
 
}  // namespace xrpl::detail