predicates.h

#pragma once
 
#include <xrpld/overlay/Message.h>
#include <xrpld/overlay/Peer.h>
 
#include <memory>
#include <set>
 
namespace xrpl {

struct SendAlways
{
    using return_type = void;
 
    std::shared_ptr<Message> const& msg;
 
    SendAlways(std::shared_ptr<Message> const& m) : msg(m)
    {
    }
 
    void
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        peer->send(msg);
    }
};
 
//------------------------------------------------------------------------------

template <typename Predicate>
struct SendIfPred
{
    using return_type = void;
 
    std::shared_ptr<Message> const& msg;
    Predicate const& predicate;
 
    SendIfPred(std::shared_ptr<Message> const& m, Predicate const& p) : msg(m), predicate(p)
    {
    }
 
    void
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        if (predicate(peer))
            peer->send(msg);
    }
};

template <typename Predicate>
SendIfPred<Predicate>
sendIf(std::shared_ptr<Message> const& m, Predicate const& f)
{
    return SendIfPred<Predicate>(m, f);
}
 
//------------------------------------------------------------------------------

template <typename Predicate>
struct SendIfNotPred
{
    using return_type = void;
 
    std::shared_ptr<Message> const& msg;
    Predicate const& predicate;
 
    SendIfNotPred(std::shared_ptr<Message> const& m, Predicate const& p) : msg(m), predicate(p)
    {
    }
 
    void
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        if (!predicate(peer))
            peer->send(msg);
    }
};

template <typename Predicate>
SendIfNotPred<Predicate>
sendIfNot(std::shared_ptr<Message> const& m, Predicate const& f)
{
    return SendIfNotPred<Predicate>(m, f);
}
 
//------------------------------------------------------------------------------

struct MatchPeer
{
    Peer const* matchPeer;
 
    MatchPeer(Peer const* match = nullptr) : matchPeer(match)
    {
    }
 
    bool
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        return (matchPeer != nullptr) && (peer.get() == matchPeer);
    }
};
 
//------------------------------------------------------------------------------

struct PeerInCluster
{
    MatchPeer skipPeer;
 
    PeerInCluster(Peer const* skip = nullptr) : skipPeer(skip)
    {
    }
 
    bool
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        if (skipPeer(peer))
            return false;
 
        if (!peer->cluster())
            return false;
 
        return true;
    }
};
 
//------------------------------------------------------------------------------

struct PeerInSet
{
    std::set<Peer::id_t> const& peerSet;
 
    PeerInSet(std::set<Peer::id_t> const& peers) : peerSet(peers)
    {
    }
 
    bool
    operator()(std::shared_ptr<Peer> const& peer) const
    {
        return peerSet.contains(peer->id());
    }
};
 
}  // namespace xrpl