BasicNetwork.h

#pragma once
 
#include <csf/Digraph.h>
#include <csf/Scheduler.h>
 
#include <cassert>
 
namespace xrpl::test::csf {
template <class Peer>
class BasicNetwork
{
    using peer_type = Peer;
 
    using clock_type = Scheduler::clock_type;
 
    using duration = clock_type::duration;
 
    using time_point = clock_type::time_point;
 
    struct LinkType
    {
        bool inbound = false;
        duration delay{};
        time_point established;
        LinkType() = default;
        LinkType(bool inbound, duration delay, time_point established)
            : inbound(inbound), delay(delay), established(established)
        {
        }
    };
 
    Scheduler& scheduler_;
    Digraph<Peer, LinkType> links_;
 
public:
    BasicNetwork(BasicNetwork const&) = delete;
    BasicNetwork&
    operator=(BasicNetwork const&) = delete;
 
    BasicNetwork(Scheduler& s);

    bool
    connect(Peer const& from, Peer const& to, duration const& delay = std::chrono::seconds{0});

    bool
    disconnect(Peer const& peer1, Peer const& peer2);

    template <class Function>
    void
    send(Peer const& from, Peer const& to, Function&& f);

    auto
    links(Peer const& from)
    {
        return links_.outEdges(from);
    }

    [[nodiscard]] Digraph<Peer, LinkType> const&
    graph() const
    {
        return links_;
    }
};
//------------------------------------------------------------------------------
template <class Peer>
BasicNetwork<Peer>::BasicNetwork(Scheduler& s) : scheduler_(s)
{
}
 
template <class Peer>
inline bool
BasicNetwork<Peer>::connect(Peer const& from, Peer const& to, duration const& delay)
{
    if (to == from)
        return false;
    time_point const now = scheduler_.now();
    if (!links_.connect(from, to, LinkType{false, delay, now}))
        return false;
    auto const result = links_.connect(to, from, LinkType{true, delay, now});
    (void)result;
    assert(result);
    return true;
}
 
template <class Peer>
inline bool
BasicNetwork<Peer>::disconnect(Peer const& peer1, Peer const& peer2)
{
    if (!links_.disconnect(peer1, peer2))
        return false;
    bool const r = links_.disconnect(peer2, peer1);
    (void)r;
    assert(r);
    return true;
}
 
template <class Peer>
template <class Function>
inline void
BasicNetwork<Peer>::send(Peer const& from, Peer const& to, Function&& f)
{
    auto link = links_.edge(from, to);
    if (!link)
        return;
    time_point const sent = scheduler_.now();
    scheduler_.in(link->delay, [from, to, sent, f = std::forward<Function>(f), this] {
        // only process if still connected and connection was
        // not broken since the message was sent
        if (auto l = links_.edge(from, to); l && l->established <= sent)
        {
            f();
        }
    });
}
 
}  // namespace xrpl::test::csf