Bootcache.h

#pragma once
 
#include <xrpl/beast/net/IPEndpoint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/PropertyStream.h>
#include <xrpl/peerfinder/Types.h>
#include <xrpl/peerfinder/detail/Store.h>
#include <xrpl/peerfinder/detail/Tuning.h>
 
#include <boost/bimap.hpp>
#include <boost/bimap/multiset_of.hpp>
#include <boost/bimap/unordered_set_of.hpp>
#include <boost/iterator/transform_iterator.hpp>
 
#include <functional>
 
namespace xrpl::peer_finder {

class Bootcache
{
private:
    class Entry
    {
    public:
        Entry(int valence) : valence_(valence)
        {
        }
 
        int&
        valence()
        {
            return valence_;
        }
 
        [[nodiscard]] int
        valence() const
        {
            return valence_;
        }
 
        friend bool
        operator<(Entry const& lhs, Entry const& rhs)
        {
            return lhs.valence() > rhs.valence();
        }
 
    private:
        int valence_;
    };
 
    using left_t = boost::bimaps::
        unordered_set_of<beast::ip::Endpoint, boost::hash<beast::ip::Endpoint>, std::equal_to<>>;
    using right_t = boost::bimaps::multiset_of<Entry, std::less<>>;
    using map_type = boost::bimap<left_t, right_t>;
    using value_type = map_type::value_type;
 
    struct Transform
    {
        using first_argument_type = map_type::right_map::const_iterator::value_type const&;
        using result_type = beast::ip::Endpoint const&;
 
        explicit Transform() = default;
 
        beast::ip::Endpoint const&
        operator()(map_type::right_map::const_iterator::value_type const& v) const
        {
            return v.get_left();
        }
    };
 
private:
    map_type map_;
 
    Store& store_;
    clock_type& clock_;
    beast::Journal journal_;
 
    // Time after which we can update the database again
    clock_type::time_point whenUpdate_;
 
    // Set to true when a database update is needed
    bool needsUpdate_{false};
 
public:
    static constexpr int kStaticValence = 32;
 
    using iterator = boost::transform_iterator<Transform, map_type::right_map::const_iterator>;
 
    using const_iterator = iterator;
 
    Bootcache(Store& store, clock_type& clock, beast::Journal journal);
 
    ~Bootcache();

    [[nodiscard]] bool
    empty() const;

    [[nodiscard]] map_type::size_type
    size() const;

    [[nodiscard]] const_iterator
    begin() const;
    [[nodiscard]] const_iterator
    cbegin() const;
    [[nodiscard]] const_iterator
    end() const;
    [[nodiscard]] const_iterator
    cend() const;
    void
    clear();

    void
    load();

    bool
    insert(beast::ip::Endpoint const& endpoint);

    bool
    insertStatic(beast::ip::Endpoint const& endpoint);

    void
    onSuccess(beast::ip::Endpoint const& endpoint);

    void
    onFailure(beast::ip::Endpoint const& endpoint);

    void
    periodicActivity();

    void
    onWrite(beast::PropertyStream::Map& map);
 
private:
    void
    prune();
    void
    update();
    void
    checkUpdate();
    void
    flagForUpdate();
};
 
}  // namespace xrpl::peer_finder