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))
    {
    }
 
    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::tnTRANSACTION_NM, 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)}
    {
    }
 
    bool
    exists(Tx::ID const& entry) const
    {
        return map_->hasItem(entry);
    }
 
    boost::intrusive_ptr<SHAMapItem const> const&
    find(Tx::ID const& entry) const
    {
        return map_->peekItem(entry);
    }
 
    ID
    id() const
    {
        return map_->getHash().as_uint256();
    }
 
    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