PendingConVarQueries.hpp

Go to the documentation of this file.

#pragma once
 
#include <VoltMod/Core/Slots/Slot.hpp>
#include <VoltMod/Hooks/ClientConVars.hpp>
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace VoltMod
{
 
/** @brief One outstanding client convar query, identified by the cookie sent to the client. */
struct PendingConVarQuery
{
    std::string Name;                       ///< Convar name the query asked for.
    ClientConVars::QueryCallback Callback;  ///< Invoked once, when a matching answer arrives.
    double SentAtSec = 0.0;                 ///< Caller-supplied monotonic timestamp of the send.
    int Cookie = -1;                        ///< Cookie sent to the client; matched on the answer.
};
 
/**
 * @brief Bookkeeping for @ref ClientConVars: per-slot, cookie-keyed queries awaiting an answer.
 *
 * Split out of the service so the matching and expiry rules are testable without the SDK. Time is
 * caller-supplied (seconds, any monotonic origin) and expiry is lazy: nothing is dropped until the
 * next Prune() for that slot, which the service runs on every Query().
 *
 * A client need never answer, so the table is capped per slot - beyond @ref MaxPendingPerSlot,
 * queries are refused rather than queued behind a silent client.
 */
class PendingConVarQueries
{
public:
    /** Outstanding queries allowed per slot before Query() starts refusing. */
    static constexpr size_t MaxPendingPerSlot = 11;
 
    /** Age at which an unanswered query is dropped, in seconds. */
    static constexpr double TimeoutSec = 10.0;
 
    /** Largest cookie handed out; the protobuf field is an int32. */
    static constexpr uint32_t MaxCookie = 0x7FFFFFFF;
 
    /** Drop @p slot's queries older than @ref TimeoutSec. Their callbacks never fire. */
    void Prune(int slot, double now);
 
    /** The query for @p name already in flight on @p slot, or null. */
    PendingConVarQuery* Find(int slot, std::string_view name);
 
    /** True when @p slot has no room for another query. */
    bool Full(int slot) const;
 
    /**
     * Next cookie unused on @p slot, or -1 when none could be found. Cookies increase
     * monotonically and wrap back to 1 at @ref MaxCookie.
     */
    int NextCookie(int slot);
 
    /** Track a query sent with a cookie from @ref NextCookie. */
    void Add(int slot, int cookie, std::string name, ClientConVars::QueryCallback callback, double now);
 
    /**
     * Remove and return @p slot's query @p cookie, but only when @p name matches the convar it
     * asked for: a client answering with a different name is answering a question nobody posed.
     */
    std::optional<PendingConVarQuery> Take(int slot, int cookie, std::string_view name);
 
    void Clear(int slot);
    void ClearAll();
 
    size_t Count(int slot) const;
 
private:
    // A slot holds at most MaxPendingPerSlot entries, so a flat vector beats a keyed container on
    // every operation here - all of which already scan.
    std::array<std::vector<PendingConVarQuery>, MaxPlayers> _slots;
    uint32_t _cookieCounter = 0;
};
 
}  // namespace VoltMod