#pragma once
#include "check.hpp"
#include <type_traits>
#include <utility>
#include <array>
namespace eosio {
namespace detail {
template<typename Generator, std::size_t... Is>
constexpr auto generate_array_helper( Generator&& g, std::index_sequence<Is...> )
-> std::array<decltype(g(std::size_t{}, sizeof...(Is))), sizeof...(Is)>
{
return {{g(Is, sizeof...(Is))...}};
}
template<std::size_t N, typename Generator>
constexpr auto generate_array( Generator&& g ) {
return generate_array_helper( std::forward<Generator>(g), std::make_index_sequence<N>{} );
}
template<typename T, T Base, uint8_t Exponent, uint64_t Value, bool Overflow = (Value * Base < Value)>
struct largest_power_helper {
private:
static_assert( std::is_integral_v<T> && std::is_unsigned_v<T> &&!std::is_same_v<T, bool> );
static_assert( Base > 1 );
constexpr static T next_value = Value * Base;
using next = largest_power_helper<T, Base, Exponent+1, next_value>;
public:
constexpr static T value = next::value;
constexpr static uint8_t exponent = next::exponent;
};
template<typename T, T Base, uint8_t Exponent, uint64_t Value>
struct largest_power_helper<T, Base, Exponent, Value, true> {
private:
static_assert( std::is_integral_v<T> && std::is_unsigned_v<T> &&!std::is_same_v<T, bool> );
static_assert( Base > 1 );
static_assert( Exponent < 255 );
public:
constexpr static T value = Value;
constexpr static uint8_t exponent = Exponent;
};
template<typename T, T Base>
struct largest_power {
private:
using helper = largest_power_helper<T, Base, 0, 1>;
public:
constexpr static T value = helper::value;
constexpr static uint8_t exponent = helper::exponent;
};
template<typename T>
constexpr T pow( T base, uint8_t exponent ) {
if( base <= 1 ) check( false, "base must be at least 2" );
T prior = 1;
T result = prior;
for( uint8_t i = 0; i < exponent; ++i, prior = result ) {
result = prior * base;
if( result <= prior ) check( false, "overflow" );
}
return result;
}
template<typename T, T Base>
constexpr T pow_generator( std::size_t i, std::size_t ) {
return pow( Base, static_cast<uint8_t>(i) );
}
}
template<uint8_t Base, typename T = uint64_t>
inline constexpr auto powers_of_base = detail::generate_array<detail::largest_power<T, Base>::exponent + 1>( detail::pow_generator<T, Base> );
template<uint8_t Base, typename T = uint64_t>
constexpr T pow( uint8_t exponent ) {
const auto& lookup_table = powers_of_base<Base, T>;
if( exponent >= lookup_table.size() ) check( false, "overflow" );
return lookup_table[exponent];
}
}