ref_array.hpp

#include "barretenberg/common/assert.hpp"
#include <array>
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <stdexcept>
 
// TODO(https://github.com/AztecProtocol/barretenberg/issues/794) namespace this once convenient
template <typename T, std::size_t N> class RefArray {
  public:
    RefArray(const std::array<T*, N>& ptr_array)
    {
        std::size_t i = 0;
        for (T& elem : ptr_array) {
            storage[i++] = &elem;
        }
    }
    template <typename... Ts> RefArray(T& ref, Ts&... rest)
    {
        storage[0] = &ref;
        int i = 1;
        ((storage[i++] = &rest), ...);
    }
 
    T& operator[](std::size_t idx) const
    {
        ASSERT(idx < N);
        return *storage[idx];
    }
 
    class iterator {
      public:
        iterator(RefArray const* array, std::size_t pos)
            : array(array)
            , pos(pos)
        {}
 
        T& operator*() const { 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); }
 
  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 + ...)> 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 + ...);
    std::array<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[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 RefArray<T, TotalSize>{ concatenated };
}