ResolvedPeers.h

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2025 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
#ifndef SQUID_SRC_RESOLVEDPEERS_H
#define SQUID_SRC_RESOLVEDPEERS_H
 
#include "base/RefCount.h"
#include "comm/Connection.h"
#include "mem/AllocatorProxy.h"
 
#include <iosfwd>
#include <limits>
#include <utility>
 
class ResolvedPeerPath
{
public:
    explicit ResolvedPeerPath(const Comm::ConnectionPointer &conn) : connection(conn), available(true) {}
 
    Comm::ConnectionPointer connection; 
    bool available; 
};
 
class PeerConnectionPointer;
 
class ResolvedPeers: public RefCountable
{
    MEMPROXY_CLASS(ResolvedPeers);
 
public:
    // ResolvedPeerPaths in addPath() call order
    typedef std::vector<ResolvedPeerPath> Paths;
    using size_type = Paths::size_type;
    typedef RefCount<ResolvedPeers> Pointer;
 
    ResolvedPeers();
 
    bool empty() const { return !availablePaths; }
 
    void addPath(const Comm::ConnectionPointer &);
 
    void reinstatePath(const PeerConnectionPointer &);
 
    PeerConnectionPointer extractFront();
 
    PeerConnectionPointer extractPrime(const Comm::Connection &currentPeer);
 
    PeerConnectionPointer extractSpare(const Comm::Connection &currentPeer);
 
    bool haveSpare(const Comm::Connection &currentPeer);
 
    bool doneWithPrimes(const Comm::Connection &currentPeer);
 
    bool doneWithSpares(const Comm::Connection &currentPeer);
 
    bool doneWithPeer(const Comm::Connection &currentPeer);
 
    size_type size() const { return availablePaths; }
 
    bool destinationsFinalized = false;
 
    bool notificationPending = false;
 
private:
    typedef std::pair<Paths::iterator, bool> Finding;
 
    static int ConnectionFamily(const Comm::Connection &conn);
 
    Paths::iterator start();
    Finding findSpare(const Comm::Connection &currentPeer);
    Finding findPrime(const Comm::Connection &currentPeer);
    Finding findPeer(const Comm::Connection &currentPeer);
    PeerConnectionPointer extractFound(const char *description, const Paths::iterator &found);
    Finding makeFinding(const Paths::iterator &found, bool foundOther);
 
    bool doneWith(const Finding &findings) const;
 
    void increaseAvailability();
    void decreaseAvailability();
 
    Paths paths_; 
 
    size_type pathsToSkip = 0;
 
    size_type availablePaths = 0;
};
 
class PeerConnectionPointer
{
public:
    using size_type = ResolvedPeers::size_type;
 
    PeerConnectionPointer() = default;
    PeerConnectionPointer(std::nullptr_t): PeerConnectionPointer() {} 
    PeerConnectionPointer(const Comm::ConnectionPointer &conn, const size_type pos): connection_(conn), position_(pos) {}
 
    /* read-only pointer API; for Connection assignment, see finalize() */
    explicit operator bool() const { return static_cast<bool>(connection_); }
    Comm::Connection *operator->() const { assert(connection_); return connection_.getRaw(); }
    Comm::Connection &operator *() const { assert(connection_); return *connection_; }
 
    operator const Comm::ConnectionPointer&() const { return connection_; }
 
    void finalize(const Comm::ConnectionPointer &conn) { connection_ = conn; }
 
    void print(std::ostream &) const;
 
private:
    static constexpr auto npos = std::numeric_limits<size_type>::max();
 
    Comm::ConnectionPointer connection_;
 
    size_type position_ = npos;
    friend class ResolvedPeers;
};
 
std::ostream &operator <<(std::ostream &, const ResolvedPeers &);
 
inline std::ostream &
operator <<(std::ostream &os, const PeerConnectionPointer &dest)
{
    dest.print(os);
    return os;
}
 
#endif /* SQUID_SRC_RESOLVEDPEERS_H */