include/xrpl/basics/random.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/beast/xor_shift_engine.h>
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <mutex>
#include <random>
#include <type_traits>
 
namespace xrpl {
 
#ifndef __INTELLISENSE__
static_assert(
    std::is_integral<beast::xor_shift_engine::result_type>::value &&
        std::is_unsigned<beast::xor_shift_engine::result_type>::value,
    "The Ripple default PRNG engine must return an unsigned integral type.");
 
static_assert(
    std::numeric_limits<beast::xor_shift_engine::result_type>::max() >= std::numeric_limits<std::uint64_t>::max(),
    "The Ripple default PRNG engine return must be at least 64 bits wide.");
#endif
 
namespace detail {
 
// Determines if a type can be called like an Engine
template <class Engine, class Result = typename Engine::result_type>
using is_engine = std::is_invocable_r<Result, Engine>;
}  // namespace detail
 
inline beast::xor_shift_engine&
default_prng()
{
    // This is used to seed the thread-specific PRNGs on demand
    static beast::xor_shift_engine seeder = [] {
        std::random_device rng;
        std::uniform_int_distribution<std::uint64_t> distribution{1};
        return beast::xor_shift_engine(distribution(rng));
    }();
 
    // This protects the seeder
    static std::mutex m;
 
    // The thread-specific PRNGs:
    thread_local beast::xor_shift_engine engine = [] {
        std::uint64_t seed;
        {
            std::lock_guard lk(m);
            std::uniform_int_distribution<std::uint64_t> distribution{1};
            seed = distribution(seeder);
        }
        return beast::xor_shift_engine{seed};
    }();
 
    return engine;
}
 
template <class Engine, class Integral>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral min, Integral max)
{
    XRPL_ASSERT(max > min, "xrpl::rand_int : max over min inputs");
 
    // This should have no state and constructing it should
    // be very cheap. If that turns out not to be the case
    // it could be hand-optimized.
    return std::uniform_int_distribution<Integral>(min, max)(engine);
}
 
template <class Integral>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
rand_int(Integral min, Integral max)
{
    return rand_int(default_prng(), min, max);
}
 
template <class Engine, class Integral>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine, Integral max)
{
    return rand_int(engine, Integral(0), max);
}
 
template <class Integral>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
rand_int(Integral max)
{
    return rand_int(default_prng(), max);
}
 
template <class Integral, class Engine>
std::enable_if_t<std::is_integral<Integral>::value && detail::is_engine<Engine>::value, Integral>
rand_int(Engine& engine)
{
    return rand_int(engine, std::numeric_limits<Integral>::max());
}
 
template <class Integral = int>
std::enable_if_t<std::is_integral<Integral>::value, Integral>
rand_int()
{
    return rand_int(default_prng(), std::numeric_limits<Integral>::max());
}
template <class Byte, class Engine>
std::enable_if_t<
    (std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value) &&
        detail::is_engine<Engine>::value,
    Byte>
rand_byte(Engine& engine)
{
    return static_cast<Byte>(
        rand_int<Engine, std::uint32_t>(engine, std::numeric_limits<Byte>::min(), std::numeric_limits<Byte>::max()));
}
 
template <class Byte = std::uint8_t>
std::enable_if_t<(std::is_same<Byte, unsigned char>::value || std::is_same<Byte, std::uint8_t>::value), Byte>
rand_byte()
{
    return rand_byte<Byte>(default_prng());
}
template <class Engine>
inline bool
rand_bool(Engine& engine)
{
    return rand_int(engine, 1) == 1;
}
 
inline bool
rand_bool()
{
    return rand_bool(default_prng());
}
}  // namespace xrpl