ApiVersion.h

#pragma once
 
#include <xrpl/beast/core/SemanticVersion.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/jss.h>
 
#include <type_traits>
#include <utility>
 
namespace xrpl {

 
namespace RPC {
 
template <unsigned int Version>
static constexpr std::integral_constant<unsigned, Version> kApiVersion = {};
 
static constexpr auto kApiInvalidVersion = kApiVersion<0>;
static constexpr auto kApiMinimumSupportedVersion = kApiVersion<1>;
static constexpr auto kApiMaximumSupportedVersion = kApiVersion<2>;
static constexpr auto kApiVersionIfUnspecified = kApiVersion<1>;
static constexpr auto kApiCommandLineVersion = kApiVersion<1>;  // TODO Bump to 2 later
static constexpr auto kApiBetaVersion = kApiVersion<3>;
static constexpr auto kApiMaximumValidVersion = kApiBetaVersion;
 
static_assert(kApiInvalidVersion < kApiMinimumSupportedVersion);
static_assert(
    kApiVersionIfUnspecified >= kApiMinimumSupportedVersion &&
    kApiVersionIfUnspecified <= kApiMaximumSupportedVersion);
static_assert(
    kApiCommandLineVersion >= kApiMinimumSupportedVersion &&
    kApiCommandLineVersion <= kApiMaximumSupportedVersion);
static_assert(kApiMaximumSupportedVersion >= kApiMinimumSupportedVersion);
static_assert(kApiBetaVersion >= kApiMaximumSupportedVersion);
static_assert(kApiMaximumValidVersion >= kApiMaximumSupportedVersion);
 
inline void
setVersion(json::Value& parent, unsigned int apiVersion, bool betaEnabled)
{
    XRPL_ASSERT(apiVersion != kApiInvalidVersion, "xrpl::RPC::setVersion : input is valid");
 
    auto& retObj = parent[jss::version] = json::ValueType::Object;
 
    if (apiVersion == kApiVersionIfUnspecified)
    {
        // API version numbers used in API version 1
        static beast::SemanticVersion const kFirstVersion{"1.0.0"};
        static beast::SemanticVersion const kGoodVersion{"1.0.0"};
        static beast::SemanticVersion const kLastVersion{"1.0.0"};
 
        retObj[jss::first] = kFirstVersion.print();
        retObj[jss::good] = kGoodVersion.print();
        retObj[jss::last] = kLastVersion.print();
    }
    else
    {
        retObj[jss::first] = kApiMinimumSupportedVersion.value;
        retObj[jss::last] = betaEnabled ? kApiBetaVersion : kApiMaximumSupportedVersion;
    }
}

inline unsigned int
getAPIVersionNumber(json::Value const& jv, bool betaEnabled)
{
    static json::Value const kMinVersion(RPC::kApiMinimumSupportedVersion);
    json::Value const maxVersion(
        betaEnabled ? RPC::kApiBetaVersion : RPC::kApiMaximumSupportedVersion);
 
    if (!jv.isObject() || !jv.isMember(jss::api_version))
        return RPC::kApiVersionIfUnspecified;
 
    try
    {
        auto const& rawVersion = jv[jss::api_version];
        switch (rawVersion.type())
        {
            case json::ValueType::Int:
                if (rawVersion.asInt() < 0)
                    return RPC::kApiInvalidVersion;
                [[fallthrough]];
            case json::ValueType::UInt: {
                auto const apiVersion = rawVersion.asUInt();
                if (apiVersion < kMinVersion || apiVersion > maxVersion)
                    return RPC::kApiInvalidVersion;
                return apiVersion;
            }
            default:
                return RPC::kApiInvalidVersion;
        }
    }
    catch (...)
    {
        return RPC::kApiInvalidVersion;
    }
}
 
}  // namespace RPC
 
template <unsigned MinVer, unsigned MaxVer, typename Fn, typename... Args>
void
forApiVersions(Fn const& fn, Args&&... args)
    requires                                         //
    (MaxVer >= MinVer) &&                            //
    (MinVer >= RPC::kApiMinimumSupportedVersion) &&  //
    (RPC::kApiMaximumValidVersion >= MaxVer) && requires {
        fn(std::integral_constant<unsigned int, MinVer>{}, std::forward<Args>(args)...);
        fn(std::integral_constant<unsigned int, MaxVer>{}, std::forward<Args>(args)...);
    }
{
    static constexpr auto kSize = MaxVer + 1 - MinVer;
    [&]<std::size_t... Offset>(std::index_sequence<Offset...>) {
        // NOLINTBEGIN(bugprone-use-after-move)
        (((void)fn(
             std::integral_constant<unsigned int, MinVer + Offset>{}, std::forward<Args>(args)...)),
         ...);
        // NOLINTEND(bugprone-use-after-move)
    }(std::make_index_sequence<kSize>{});
}
 
template <typename Fn, typename... Args>
void
forAllApiVersions(Fn const& fn, Args&&... args)
    requires requires {
        forApiVersions<RPC::kApiMinimumSupportedVersion, RPC::kApiMaximumValidVersion>(
            fn, std::forward<Args>(args)...);
    }
{
    forApiVersions<RPC::kApiMinimumSupportedVersion, RPC::kApiMaximumValidVersion>(
        fn, std::forward<Args>(args)...);
}
 
}  // namespace xrpl