shared_shifted_virtual_zeroes_array.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/log.hpp"
#include "barretenberg/polynomials/backing_memory.hpp"
#include <cstddef>
#include <memory>
 
template <typename T> struct SharedShiftedVirtualZeroesArray {
 
    void set(size_t index, const T& value)
    {
        BB_ASSERT_GTE(index, start_);
        BB_ASSERT_LT(index, end_);
        data()[index - start_] = value;
    }
 
    const T& get(size_t index, size_t virtual_padding = 0) const
    {
        static const T zero{};
        if (index >= virtual_size_ + virtual_padding) {
            info("BAD GET(): index = ",
                 index,
                 ", virtual_size_ = ",
                 virtual_size_,
                 ", virtual_padding = ",
                 virtual_padding);
        }
        BB_ASSERT_LT(index, virtual_size_ + virtual_padding);
        if (index >= start_ && index < end_) {
            return data()[index - start_];
        }
        return zero; // Return default element when index is out of the actual filled size
    }
 
    T* data() { return backing_memory_ ? backing_memory_->raw_data() : nullptr; }
    const T* data() const { return backing_memory_ ? backing_memory_->raw_data() : nullptr; }
    // Our size is end_ - start_. Note that we need to offset end_ when doing a shift to
    // correctly maintain the size.
    size_t size() const { return end_ - start_; }
    // Getter for consistency with size();
    size_t virtual_size() const { return virtual_size_; }
 
    void increase_virtual_size(const size_t new_virtual_size)
    {
        BB_ASSERT_GTE(new_virtual_size, virtual_size_); // shrinking is not allowed
        virtual_size_ = new_virtual_size;
    }
 
    T& operator[](size_t index)
    {
        BB_ASSERT_GTE(index, start_);
        BB_ASSERT_LT(index, end_);
        return data()[index - start_];
    }
    // get() is more useful, but for completeness with the non-const operator[]
    const T& operator[](size_t index) const
    {
        BB_ASSERT_GTE(index, start_);
        BB_ASSERT_LT(index, end_);
        return data()[index - start_];
    }
 
    // MEMBERS:
    size_t start_ = 0;
 
    size_t end_ = 0;
 
    size_t virtual_size_ = 0;
 
    std::shared_ptr<BackingMemory<T>> backing_memory_;
};