Rules.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/protocol/STVector256.h>
 
#include <memory>
#include <optional>
#include <unordered_set>
#include <utility>
 
namespace xrpl {

bool
isFeatureEnabled(uint256 const& feature, bool resultIfNoRules);

bool
isFeatureEnabled(uint256 const& feature);
 
class DigestAwareReadView;

class Rules
{
private:
    class Impl;
 
    // Carrying impl by shared_ptr makes Rules comparatively cheap to pass
    // by value.
    std::shared_ptr<Impl const> impl_;
 
public:
    Rules(Rules const&) = default;
 
    Rules(Rules&&) = default;
 
    Rules&
    operator=(Rules const&) = default;
 
    Rules&
    operator=(Rules&&) = default;
 
    Rules() = delete;

    explicit Rules(std::unordered_set<uint256, beast::Uhash<>> const& presets);
 
private:
    // Allow a friend function to construct Rules.
    friend Rules
    makeRulesGivenLedger(DigestAwareReadView const& ledger, Rules const& current);
 
    friend Rules
    makeRulesGivenLedger(
        DigestAwareReadView const& ledger,
        std::unordered_set<uint256, beast::Uhash<>> const& presets);
 
    Rules(
        std::unordered_set<uint256, beast::Uhash<>> const& presets,
        std::optional<uint256> const& digest,
        STVector256 const& amendments);
 
    [[nodiscard]] std::unordered_set<uint256, beast::Uhash<>> const&
    presets() const;
 
public:
    [[nodiscard]] bool
    enabled(uint256 const& feature) const;

    bool
    operator==(Rules const&) const;
};
 
std::optional<Rules> const&
getCurrentTransactionRules();
 
void
setCurrentTransactionRules(std::optional<Rules> r);

class CurrentTransactionRulesGuard
{
public:
    explicit CurrentTransactionRulesGuard(Rules r) : saved_(getCurrentTransactionRules())
    {
        setCurrentTransactionRules(std::move(r));
    }
 
    ~CurrentTransactionRulesGuard()
    {
        setCurrentTransactionRules(saved_);
    }
 
    CurrentTransactionRulesGuard() = delete;
    CurrentTransactionRulesGuard(CurrentTransactionRulesGuard const&) = delete;
    CurrentTransactionRulesGuard&
    operator=(CurrentTransactionRulesGuard const&) = delete;
 
private:
    std::optional<Rules> saved_;
};
 
class NumberMantissaScaleGuard;
 
bool
useRulesGuards(Rules const& rules);
 
void
createGuards(
    Rules const& rules,
    std::optional<CurrentTransactionRulesGuard>& rulesGuard,
    std::optional<NumberMantissaScaleGuard>& mantissaScaleGuard);
 
}  // namespace xrpl