ref_vector.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <initializer_list>
#include <iterator>
#include <span>
#include <stdexcept>
#include <vector>
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/ref_array.hpp"
 
namespace bb {
template <typename T> class RefVector {
  public:
    RefVector() = default;
    explicit RefVector(const std::vector<T*>& ptr_vector)
        : storage(ptr_vector)
    {}
 
    explicit RefVector(std::vector<T>& vector)
        : storage(vector.size())
    {
        for (size_t i = 0; i < vector.size(); i++) {
            storage[i] = &vector[i];
        }
    }
 
    template <typename... Ts>
    RefVector(T& first, Ts&... refs)
        : storage{ &first, &refs... }
    {}
 
    template <std::size_t N>
    RefVector(const RefArray<T, N>& ref_array)
        : storage(ref_array.size())
    {
        for (std::size_t i = 0; i < ref_array.size(); ++i) {
            storage[i] = &ref_array[i];
        }
    }
 
    template <std::size_t N>
    RefVector(std::span<T, N> sp)
        : storage(sp.size())
    {
        for (std::size_t i = 0; i < sp.size(); ++i) {
            storage[i] = &sp[i];
        }
    }
 
    // Note: making this a constructor gives problems in prover_instance.cpp.
    static RefVector from_span(const std::span<T>& span)
    {
        RefVector ret;
        ret.storage.reserve(span.size());
        for (std::size_t i = 0; i < span.size(); ++i) {
            ret.push_back(span[i]);
        }
        return ret;
    }
 
    T& operator[](std::size_t idx) const
    {
        BB_ASSERT_DEBUG(idx < storage.size());
        return *storage[idx];
    }
 
    class iterator {
      public:
        iterator(RefVector const* vector, std::size_t pos)
            : vector(vector)
            , pos(pos)
        {}
 
        T& operator*() const { return (*vector)[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:
        RefVector const* vector;
        std::size_t pos;
    };
 
    std::size_t size() const { return storage.size(); }
 
    void push_back(T& element) { storage.push_back(&element); }
    iterator begin() const { return iterator(this, 0); }
    iterator end() const { return iterator(this, storage.size()); }
 
    template <typename ConvertibleFromT> operator std::vector<ConvertibleFromT>() const
    {
        std::vector<ConvertibleFromT> ret;
        ret.reserve(storage.size());
        for (T* elem : storage) {
            ret.push_back(*elem);
        }
        return ret;
    }
 
    std::vector<T*>& get_storage() { return storage; }
    const std::vector<T*>& get_storage() const { return storage; }
 
  private:
    std::vector<T*> storage;
};
 
template <typename T, typename... Ts> RefVector(T&, Ts&...) -> RefVector<T>;
 
template <typename T> RefVector<T> concatenate(const RefVector<T>& ref_vector, const auto&... ref_vectors)
{
    RefVector<T> concatenated;
    // Reserve our final space
    concatenated.get_storage().reserve(ref_vector.size() + (ref_vectors.size() + ...));
 
    auto append = [&](const auto& vec) {
        std::copy(vec.get_storage().begin(), vec.get_storage().end(), std::back_inserter(concatenated.get_storage()));
    };
 
    append(ref_vector);
    // Unpack and append each RefVector's elements to concatenated
    (append(ref_vectors), ...);
 
    return concatenated;
}
 
/* @details Ensures a nested vector holds reference objects */
template <typename T> static std::vector<RefVector<T>> to_vector_of_ref_vectors(std::vector<std::vector<T>>& vec)
{
    std::vector<RefVector<T>> result;
    for (std::vector<T>& inner : vec) {
        result.push_back(RefVector{ inner });
    }
    return result;
}
} // namespace bb