RCLCxTx.h

#pragma once
 
#include <xrpl/shamap/SHAMap.h>
 
namespace xrpl {

class RCLCxTx
{
public:
    using ID = uint256;

    RCLCxTx(boost::intrusive_ptr<SHAMapItem const> txn) : tx(std::move(txn))
    {
    }

    [[nodiscard]] ID const&
    id() const
    {
        return tx->key();
    }

    boost::intrusive_ptr<SHAMapItem const> tx;
};

class RCLTxSet
{
public:
    using ID = uint256;
    using Tx = RCLCxTx;
 
    //< Provide a mutable view of a TxSet
    class MutableTxSet
    {
        friend class RCLTxSet;
        std::shared_ptr<SHAMap> map_;
 
    public:
        MutableTxSet(RCLTxSet const& src) : map_{src.map->snapShot(true)}
        {
        }

        bool
        insert(Tx const& t)
        {
            return map_->addItem(SHAMapNodeType::TnTransactionNm, t.tx);
        }

        bool
        erase(Tx::ID const& entry)
        {
            return map_->delItem(entry);
        }
    };

    RCLTxSet(std::shared_ptr<SHAMap> m) : map{std::move(m)}
    {
        XRPL_ASSERT(map, "xrpl::RCLTxSet::MutableTxSet::RCLTxSet : non-null input");
    }

    RCLTxSet(MutableTxSet const& m) : map{m.map_->snapShot(false)}
    {
    }

    [[nodiscard]] bool
    exists(Tx::ID const& entry) const
    {
        return map->hasItem(entry);
    }

    [[nodiscard]] boost::intrusive_ptr<SHAMapItem const> const&
    find(Tx::ID const& entry) const
    {
        return map->peekItem(entry);
    }

    [[nodiscard]] ID
    id() const
    {
        return map->getHash().asUInt256();
    }

    [[nodiscard]] std::map<Tx::ID, bool>
    compare(RCLTxSet const& j) const
    {
        SHAMap::Delta delta;
 
        // Bound the work we do in case of a malicious
        // map from a trusted validator
        map->compare(*(j.map), delta, 65536);
 
        std::map<uint256, bool> ret;
        for (auto const& [k, v] : delta)
        {
            XRPL_ASSERT(
                (v.first && !v.second) || (v.second && !v.first),
                "xrpl::RCLTxSet::compare : either side is set");
 
            ret[k] = static_cast<bool>(v.first);
        }
        return ret;
    }

    std::shared_ptr<SHAMap> map;
};
}  // namespace xrpl