Sim.h

#pragma once
 
#include <test/csf/BasicNetwork.h>
#include <test/csf/CollectorRef.h>
#include <test/csf/Digraph.h>
#include <test/csf/Peer.h>
#include <test/csf/PeerGroup.h>
#include <test/csf/Scheduler.h>
#include <test/csf/SimTime.h>
#include <test/csf/TrustGraph.h>
 
#include <deque>
#include <iostream>
#include <random>
 
namespace xrpl::test::csf {

class BasicSink : public beast::Journal::Sink
{
    Scheduler::clock_type const& clock_;
 
public:
    BasicSink(Scheduler::clock_type const& clock)
        : Sink(beast::Severity::Disabled, false), clock_{clock}
    {
    }
 
    void
    write(beast::Severity level, std::string const& text) override
    {
        if (level < threshold())
            return;
 
        std::cout << clock_.now().time_since_epoch().count() << " " << text << std::endl;
    }
 
    void
    writeAlways(beast::Severity level, std::string const& text) override
    {
        std::cout << clock_.now().time_since_epoch().count() << " " << text << std::endl;
    }
};
 
class Sim
{
    // Use a deque to have stable pointers even when dynamically adding peers
    //  - Alternatively consider using unique_ptrs allocated from arena
    std::deque<Peer> peers_;
    PeerGroup allPeers_;
 
public:
    std::mt19937_64 rng;
    Scheduler scheduler;
    BasicSink sink;
    beast::Journal j;
    LedgerOracle oracle;
    BasicNetwork<Peer*> net;
    TrustGraph<Peer*> trustGraph;
    CollectorRefs collectors;

    // NOLINTNEXTLINE(bugprone-random-generator-seed): fixed seed for reproducible test
    Sim() : sink{scheduler.clock()}, j{sink}, net{scheduler}
    {
    }

    PeerGroup
    createGroup(std::size_t numPeers)
    {
        std::vector<Peer*> newPeers;
        newPeers.reserve(numPeers);
        for (std::size_t i = 0; i < numPeers; ++i)
        {
            peers_.emplace_back(
                PeerID{static_cast<std::uint32_t>(peers_.size())},
                scheduler,
                oracle,
                net,
                trustGraph,
                collectors,
                j);
            newPeers.emplace_back(&peers_.back());
        }
        PeerGroup res{newPeers};
        allPeers_ = allPeers_ + res;
        return res;
    }

    std::size_t
    size() const
    {
        return peers_.size();
    }

    void
    run(int ledgers);

    void
    run(SimDuration const& dur);

    static bool
    synchronized(PeerGroup const& g);

    bool
    synchronized() const;

    std::size_t
    branches(PeerGroup const& g) const;

    std::size_t
    branches() const;
};
 
}  // namespace xrpl::test::csf