boxedContainer.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_BOXED_CONTAINER_H
#define PXR_EXEC_VDF_BOXED_CONTAINER_H
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/boxedContainerTraits.h"
 
#include "pxr/base/tf/smallVector.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class Vdf_BoxedRanges
{
public:
    struct Range
    {
        unsigned int begin;
        unsigned int end;
    };
 
    Vdf_BoxedRanges() = default;
 
    explicit Vdf_BoxedRanges(unsigned int n)
        : _ranges(1, Range{0, n})
    {}
 
    unsigned int GetNumRanges() const {
        return _ranges.size();
    }
 
    Range GetRange(unsigned int i) const {
        return _ranges[i];
    }
 
    void AppendRange(unsigned int begin, unsigned int end) {
        _ranges.push_back(Range{begin, end});
    }
 
    // Overload for ADL swap idiom
    friend inline void swap(Vdf_BoxedRanges &lhs, Vdf_BoxedRanges &rhs) {
        lhs._ranges.swap(rhs._ranges);
    }
 
private:
    // The individual ranges stored in this vector denoted by the end element
    // index of each range.
    TfSmallVector<Range, 1> _ranges;
};
 
template<typename T>
class Vdf_BoxedContainer
{
    static_assert(
        !Vdf_IsBoxedContainer<T>, "Recursive boxing is not allowed");
 
    // Adjust the local capacity of our data so that we use as much local
    // capacity as we can without growing sizeof(_DataVec).  We do this so
    // that the boxed container always fits in Vdf_VectorData::DataHolder.
    // Otherwise, we would have to separately allocate the boxed container
    // from the vector impl, which defeats the purpose of TfSmallVector's
    // local storage.
    static const TfSmallVectorBase::size_type N =
        TfSmallVectorBase::ComputeSerendipitousLocalCapacity<T>();
    using _DataVec = TfSmallVector<T, N>;
 
public:
 
    Vdf_BoxedContainer() = default;
 
    explicit Vdf_BoxedContainer(unsigned int n) :
        _data(n, _DataVec::DefaultInit),
        _ranges(n)
    {}
 
    bool operator==(const Vdf_BoxedContainer &rhs) const {
        return _data == rhs._data;
    }
 
    bool operator!=(const Vdf_BoxedContainer &rhs) const {
        return !operator==(rhs);
    }
 
    bool empty() const {
        return _data.empty();
    }
 
    size_t size() const {
        return _data.size();
    }
 
    void reserve(unsigned int n) {
        _data.reserve(n);
    }
 
    const T &operator[](unsigned int i) const {
        return _data[i];
    }
 
    T &operator[](unsigned int i) {
        return _data[i];
    }
 
    const T *data() const {
        return _data.data();
    }
 
    T *data() {
        return _data.data();
    }
 
    const Vdf_BoxedRanges &GetRanges() const {
        return _ranges;
    }
 
    template<typename Iterator>
    void AppendRange(Iterator begin, Iterator end);
 
    // Overload for ADL swap idiom
    friend inline void swap(Vdf_BoxedContainer &lhs, Vdf_BoxedContainer &rhs) {
        lhs._data.swap(rhs._data);
        swap(lhs._ranges, rhs._ranges);
    }
 
private:
 
    // The elements stored in this container.
    _DataVec _data;
 
    // The individual ranges stored in this vector denoted by the end element
    // index of each range.
    Vdf_BoxedRanges _ranges;
 
};
 
 
template<typename T>
template<typename Iterator>
void
Vdf_BoxedContainer<T>::AppendRange(Iterator begin, Iterator end) {
    const unsigned int previousSize = _data.size();
    _data.insert(_data.end(), begin, end);
    _ranges.AppendRange(previousSize, _data.size());
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif /* PXR_EXEC_VDF_BOXED_CONTAINER_H */