ref_array.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/common/assert.hpp"
#include <array>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <span>
#include <stdexcept>
#include <type_traits>
 
namespace bb {
template <typename T, std::size_t N> class RefArray {
  public:
    RefArray() = default;
    RefArray(const std::array<T*, N>& ptr_array)
    {
        for (std::size_t i = 0; i < N; ++i) {
            storage[i] = ptr_array[i];
        }
    }
    RefArray(std::array<T, N>& arr)
    {
        for (std::size_t i = 0; i < N; ++i) {
            storage[i] = &arr[i];
        }
    }
    template <typename... Ts>
    RefArray(T& first, Ts&... refs)
        : storage{ &first, &refs... }
    {}
    RefArray(std::span<T, N> sp)
    {
        for (std::size_t i = 0; i < N; ++i) {
            storage[i] = &sp[i];
        }
    }
    RefArray(std::span<std::remove_const_t<T>, N> sp)
        requires std::is_const_v<T>
    {
        for (std::size_t i = 0; i < N; ++i) {
            storage[i] = &sp[i];
        }
    }
 
    T& operator[](std::size_t idx) const
    {
        // GCC has a bug where it has trouble analyzing zip_view
        // this is likely due to this bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104165
        // We disable this - if GCC was right, we would have caught this at runtime
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warray-bounds"
#endif
        BB_ASSERT_DEBUG(idx < N);
        return *storage[idx];
#if !defined(__clang__) && defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
    }
 
    std::array<T, N> get_copy()
    {
        std::array<T, N> data;
        for (size_t idx = 0; idx < N; idx++) {
            data[idx] = *storage[idx];
        }
 
        return data;
    }
 
    class iterator {
      public:
        iterator(RefArray const* array, std::size_t pos)
            : array(array)
            , pos(pos)
        {}
 
        T& operator*() const
        {
            BB_ASSERT_LT_NO_WASM(pos, N);
            return (*array)[pos];
        }
 
        iterator& operator++()
        {
            pos++;
            return *this;
        }
 
        iterator operator++(int)
        {
            iterator temp = *this;
            ++(*this);
            return temp;
        }
 
        bool operator==(iterator const& other) const { return pos == other.pos; }
        bool operator!=(iterator const& other) const { return pos != other.pos; }
 
      private:
        RefArray const* array;
        std::size_t pos;
    };
 
    constexpr std::size_t size() const { return N; }
    iterator begin() const { return iterator(this, 0); }
    iterator end() const { return iterator(this, N); }
 
    T** get_storage() { return storage; }
    T* const* get_storage() const { return storage; }
 
  private:
    // We are making a high-level array, for simplicity having a C array as backing makes sense.
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays)
    T* storage[N];
};
 
template <typename T, typename... Ts> RefArray(T&, Ts&...) -> RefArray<T, 1 + sizeof...(Ts)>;
 
template <typename T, std::size_t... Ns>
RefArray<T, (Ns + ...)> constexpr concatenate(const RefArray<T, Ns>&... ref_arrays)
{
    // Fold expression to calculate the total size of the new array using fold expression
    constexpr std::size_t TotalSize = (Ns + ...);
    RefArray<T, TotalSize> concatenated;
 
    std::size_t offset = 0;
    // Copies elements from a given RefArray to the concatenated array
    auto copy_into = [&](const auto& ref_array, std::size_t& offset) {
        for (std::size_t i = 0; i < ref_array.size(); ++i) {
            concatenated.get_storage()[offset + i] = &ref_array[i];
        }
        offset += ref_array.size();
    };
 
    // Fold expression to copy elements from each input RefArray to the concatenated array
    (..., copy_into(ref_arrays, offset));
 
    return concatenated;
}
 
template <typename T, std::size_t N1, std::size_t N2>
RefArray<T, N1 + N2> constexpr concatenate(std::span<T, N1> a, std::span<T, N2> b)
{
    return concatenate(RefArray<T, N1>(a), RefArray<T, N2>(b));
}
 
template <typename T, std::size_t N1, std::size_t N2>
RefArray<T, N1 + N2> constexpr concatenate(std::span<T, N1> a, const RefArray<T, N2>& b)
{
    return concatenate(RefArray<T, N1>(a), b);
}
 
template <typename T, std::size_t N1, std::size_t N2>
RefArray<T, N1 + N2> constexpr concatenate(const RefArray<T, N1>& a, std::span<T, N2> b)
{
    return concatenate(a, RefArray<T, N2>(b));
}
} // namespace bb