7 #ifndef PXR_BASE_TF_SMALL_VECTOR_H
8 #define PXR_BASE_TF_SMALL_VECTOR_H
21 #include <initializer_list>
26 #include <type_traits>
41 template <
size_t Size,
size_t Align,
size_t NumLocal>
46 template <
class ValueType,
size_t NumLocal>
69 template<
typename _ForwardIterator>
72 std::is_convertible_v<
73 typename std::iterator_traits<
74 _ForwardIterator>::iterator_category,
75 std::forward_iterator_tag
81 template <
typename Iterator>
83 Iterator
first, Iterator
last, Iterator dest) {
84 return std::uninitialized_copy(
85 std::make_move_iterator(first),
86 std::make_move_iterator(last),
94 new (p) U(std::move(*src));
100 template <
size_t Size,
size_t Align,
size_t NumLocal>
128 alignas(NumLocal == 0 ? std::alignment_of_v<void *> : Align)
129 char _local[std::max<size_t>(Size * NumLocal,
sizeof(_remote))];
155 template <
typename T, u
int32_t N>
206 std::uninitialized_fill_n(
data(), n, v);
224 _InitStorage(rhs.
size());
233 if (rhs.size() >
N) {
234 _SetRemoteStorage(rhs._GetRemoteStorage());
256 template<
typename ForwardIterator,
257 typename = _EnableIfForwardIterator<ForwardIterator>>
261 std::uninitialized_copy(first, last,
begin());
292 assign(ilist.begin(), ilist.end());
300 if (_IsLocal() && rhs._IsLocal()) {
305 std::swap_ranges(smaller->
begin(), smaller->
end(), larger->
begin());
311 (*larger)[i].~value_type();
315 std::swap(smaller->_size, larger->_size);
320 else if (!_IsLocal() && !rhs._IsLocal()) {
322 _SetRemoteStorage(rhs._GetRemoteStorage());
323 rhs._SetRemoteStorage(tmp);
337 value_type *remoteStorage = remote->_GetStorage();
347 (*local)[i].~value_type();
352 local->_SetRemoteStorage(remoteStorage);
356 std::swap(remote->_capacity, local->_capacity);
364 return _Insert(it, std::move(
v));
370 return _Insert(it, v);
376 return erase(it, it + 1);
397 for (
value_type *i = (e - num); i != e; ++i) {
415 _GrowStorage(newCapacity);
424 if (newSize <
size()) {
431 else if (newSize >
size()) {
433 std::uninitialized_fill(
data() +
size(),
data() + newSize,
v);
449 template<
typename ForwardIterator,
450 typename = _EnableIfForwardIterator<ForwardIterator>>
455 std::uninitialized_copy(first, last,
begin());
461 void assign(std::initializer_list<T> ilist) {
462 assign(ilist.begin(), ilist.end());
467 template <
typename... Args >
470 _GrowStorage(_NextCapacity());
491 template <
typename ForwardIterator>
496 typename std::iterator_traits<ForwardIterator>::iterator_category,
497 std::forward_iterator_tag>::
value,
498 "Input Iterators not supported.");
503 const bool insertAtEnd = pos ==
end();
508 std::max(_NextCapacity(), neededCapacity);
520 _GrowStorage(nextCapacity);
522 std::uninitialized_copy(first, last,
end());
523 _size += numNewElems;
533 value_type *newStorage = _Allocate(nextCapacity);
536 iterator newPos = newPrefixBegin + posI;
537 iterator newSuffixBegin = newPos + numNewElems;
539 std::uninitialized_copy(first, last, newPos);
545 _SetRemoteStorage(newStorage);
546 _capacity = nextCapacity;
560 const long numUninitMoves =
std::min(numNewElems, numMoveElems);
561 const long numInitMoves = numMoveElems - numUninitMoves;
562 const long numUninitNews = numNewElems - numUninitMoves;
563 const long numInitNews = numNewElems - numUninitNews;
566 iterator umSrc = pos + numInitMoves;
569 std::copy_backward(pos, umSrc, umDst);
572 for (
long i=0; i<numInitNews; ++i, ++
first, ++pos) {
575 std::uninitialized_copy(first, last,
end());
578 _size += numNewElems;
584 insert(pos, ilist.begin(), ilist.end());
590 back().~value_type();
736 return _GetStorage();
742 return _GetStorage();
761 return static_cast<value_type *
>(_data.GetLocalStorage());
764 return static_cast<const value_type *
>(_data.GetLocalStorage());
768 return static_cast<value_type *
>(_data.GetRemoteStorage());
771 return static_cast<const value_type *
>(_data.GetRemoteStorage());
775 _data.SetRemoteStorage(static_cast<void *>(p));
779 bool _IsLocal()
const {
780 return _capacity <=
N;
786 return _IsLocal() ? _GetLocalStorage() : _GetRemoteStorage();
792 return _IsLocal() ? _GetLocalStorage() : _GetRemoteStorage();
796 void _FreeStorage() {
798 free(_GetRemoteStorage());
819 _SetRemoteStorage(_Allocate(size));
822 #if defined(ARCH_COMPILER_GCC) && ARCH_COMPILER_GCC_MAJOR < 11
823 else if constexpr (!_data.HasLocal) {
831 _data.SetRemoteStorage(
nullptr);
839 void _GrowStorage(
const size_type newCapacity) {
840 value_type *newStorage = _Allocate(newCapacity);
844 _SetRemoteStorage(newStorage);
845 _capacity = newCapacity;
853 return cap + (cap / 2) + 1;
862 template <
typename U >
876 const size_type newCapacity = _NextCapacity();
877 value_type *newStorage = _Allocate(newCapacity);
890 _SetRemoteStorage(newStorage);
891 _capacity = newCapacity;
901 std::move_backward(newEntry, last, last + 1);
904 newEntry->~value_type();
915 _Data<value_type, N> _data;
927 template <
typename T, u
int32_t N >
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
const_reference operator[](size_type i) const
size_type capacity() const
const_reverse_iterator rend() const
typename std::enable_if< B, T >::type enable_if_t
Define Imath::enable_if_t to be std for C++14, equivalent for C++11.
const void * GetRemoteStorage() const
void push_back(const value_type &v)
void insert(iterator pos, std::initializer_list< T > ilist)
void resize(size_type newSize, const value_type &v=value_type())
reverse_iterator rbegin()
bool operator==(const TfSmallVector &rhs) const
const_iterator cbegin() const
void swap(UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &a, UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &b)
void reserve(size_type newCapacity)
static Iterator _UninitializedMove(Iterator first, Iterator last, Iterator dest)
GLsizei const GLfloat * value
std::ptrdiff_t difference_type
static void _MoveConstruct(U *p, U *src)
std::uint32_t _SizeMemberType
TfSmallVector(std::initializer_list< T > values)
Construct a new vector from initializer list.
static constexpr size_type max_size()
GLboolean GLboolean GLboolean GLboolean a
TfSmallVector(size_type n, const value_type &v)
IMATH_HOSTDEVICE constexpr bool equal(T1 a, T2 b, T3 t) IMATH_NOEXCEPT
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
GLdouble GLdouble GLdouble q
iterator erase(const_iterator it, const_iterator last)
const_reverse_iterator crbegin() const
static constexpr size_type internal_capacity()
const_iterator begin() const
bool operator!=(const TfSmallVector &rhs) const
iterator insert(const_iterator it, const value_type &v)
TfSmallVector & operator=(std::initializer_list< T > ilist)
TfSmallVector & operator=(const TfSmallVector &rhs)
void emplace_back(Args &&...args)
TfSmallVector & operator=(TfSmallVector &&rhs)
TfSmallVector(size_type n)
const_iterator end() const
TfSmallVector(size_type n, DefaultInitTag)
void SetRemoteStorage(void *p)
GLboolean GLboolean GLboolean b
std::enable_if_t< std::is_convertible_v< typename std::iterator_traits< _ForwardIterator >::iterator_category, std::forward_iterator_tag > > _EnableIfForwardIterator
void push_back(value_type &&v)
__hostdev__ uint64_t last(uint32_t i) const
iterator erase(const_iterator it)
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
std::reverse_iterator< const_iterator > const_reverse_iterator
void * GetRemoteStorage()
GLenum GLsizei GLsizei GLint * values
void insert(iterator pos, ForwardIterator first, ForwardIterator last)
const_reverse_iterator crend() const
iterator insert(const_iterator it, value_type &&v)
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
void assign(std::initializer_list< T > ilist)
#define PXR_NAMESPACE_CLOSE_SCOPE
GA_API const UT_StringHolder N
**If you just want to fire and args
TfSmallVector(ForwardIterator first, ForwardIterator last)
const_reference front() const
TfSmallVector(const TfSmallVector &rhs)
const_iterator cend() const
TfSmallVector(TfSmallVector &&rhs)
const void * GetLocalStorage() const
void assign(ForwardIterator first, ForwardIterator last)
const_reference back() const
SIM_API const UT_StringHolder distance
const TYPE * const_iterator
const_reverse_iterator rbegin() const
const T & const_reference
reference operator[](size_type i)
static constexpr bool HasLocal
void swap(TfSmallVector &rhs)
std::reverse_iterator< iterator > reverse_iterator
const value_type * data() const
static constexpr size_type ComputeSerendipitousLocalCapacity()