constexpr_utils.hpp

#pragma once
 
#include <cstddef>
#include <tuple>
#include <utility>
 
namespace barretenberg {
 
template <size_t Start, size_t End, size_t Inc, class F> constexpr void constexpr_for(F&& f)
{
    // Call function `f<Start>()` iff Start < End
    if constexpr (Start < End) {
        // F must be a template lambda with a single **typed** template parameter that represents the iterator
        // (e.g. [&]<size_t i>(){ ... } is good)
        // (and [&]<typename i>(){ ... } won't compile!)
 
        f.template operator()<Start>();
 
        // Once we have executed `f`, we recursively call the `constexpr_for` function, increasing the value of `Start`
        // by `Inc`
        constexpr_for<Start + Inc, End, Inc>(f);
    }
}
 
template <const auto& container, auto key> constexpr bool constexpr_find()
{
    // using ElementType = typename std::remove_extent<ContainerType>::type;
    bool found = false;
    constexpr_for<0, container.size(), 1>([&]<size_t k>() {
        if constexpr (std::get<k>(container) == key) {
            found = true;
        }
    });
    return found;
}
 
template <typename T, std::size_t... Is>
constexpr std::array<T, sizeof...(Is)> create_array(T value, std::index_sequence<Is...> /*unused*/)
{
    // cast Is to void to remove the warning: unused value
    std::array<T, sizeof...(Is)> result = { { (static_cast<void>(Is), value)... } };
    return result;
}
 
template <typename T, size_t N> constexpr std::array<T, N> create_empty_array()
{
    return create_array(T(0), std::make_index_sequence<N>());
}
}; // namespace barretenberg