49 #ifndef __UT_ARRAY_H_INCLUDED__
50 #define __UT_ARRAY_H_INCLUDED__
66 #include <initializer_list>
68 #include <type_traits>
97 myData = capacity ? allocateCapacity(capacity) :
nullptr;
120 explicit UT_Array(std::initializer_list<T> init);
143 if (check_dup && ((idx =
find(t)) != -1))
161 template <
typename...
S>
166 template <
typename Y>
176 template <
typename F>
177 using IsBoolComp = decltype(std::declval<F>()(std::declval<T>(),
189 template <typename ComparatorBool = Less<
T>,
190 typename = IsBoolComp<ComparatorBool>>
199 template <
typename ComparatorBool = Less<T>,
200 typename = IsBoolComp<ComparatorBool>>
211 template <
typename ComparatorBool = Less<T>,
212 typename = IsBoolComp<ComparatorBool>>
214 ComparatorBool is_less = {})
const;
225 template <typename ComparatorBool = Less<
T>>
227 bool allow_dups, ComparatorBool is_less = {});
229 template <
typename ComparatorBool = Less<T>,
230 typename = IsBoolComp<ComparatorBool>>
232 ComparatorBool is_less = {})
const;
234 template <
typename ComparatorBool = Less<T>,
235 typename = IsBoolComp<ComparatorBool>>
238 ComparatorBool is_less = {});
239 template <
typename ComparatorBool = Less<T>,
240 typename = IsBoolComp<ComparatorBool>>
244 ComparatorBool is_less = {})
const;
245 template <
typename ComparatorBool = Less<T>,
246 typename = IsBoolComp<ComparatorBool>>
249 ComparatorBool is_less = {});
250 template <
typename ComparatorBool = Less<T>,
251 typename = IsBoolComp<ComparatorBool>>
255 ComparatorBool is_less = {})
const;
256 template <
typename ComparatorBool = Less<T>,
257 typename = IsBoolComp<ComparatorBool>>
260 ComparatorBool is_less = {});
261 template <
typename ComparatorBool = Less<T>,
262 typename = IsBoolComp<ComparatorBool>>
266 ComparatorBool is_less = {})
const;
330 {
return (index >= 0 && index < mySize); }
336 template <
typename S>
346 exint idx = --mySize;
366 template <
typename IsEqual>
370 template <
typename IsEqual>
393 template <
typename S>
411 return (&t >= myData && &t < (myData + mySize))
417 template <
typename ComparatorBool = Less<T>,
418 typename = IsBoolComp<ComparatorBool>>
419 void sort(ComparatorBool is_less = {})
421 std::sort(myData, myData + mySize, is_less);
431 template <typename ComparatorBool,
432 typename = IsBoolComp<ComparatorBool>>
436 std::sort(myData, myData + mySize, is_less);
447 template<
typename ComparatorBool = Less<T>>
458 template<
typename ComparatorBool>
471 std::stable_sort(
array() + start,
array() + end, is_less);
475 template <
typename I,
typename V,
typename ComparatorBool>
485 {
return myCompare(myValues(a), myValues(b)); }
488 const ComparatorBool &myCompare;
499 template <
typename I,
typename ComparatorBool>
501 ComparatorBool is_less)
const
503 IndexedCompare<I, T, ComparatorBool>
compare(*
this, is_less);
504 std::stable_sort(indices.
getArray(),
511 template <
typename I,
typename ComparatorBool>
513 ComparatorBool is_less)
const
524 template <
typename K,
typename ComparatorBool>
542 template <
typename CompareEqual>
549 template<
typename ComparatorBool = Less<T>>
560 template <
typename ComparatorBool = Less<T>>
582 exint newcapacity = mincapacity;
583 if (bumped > mincapacity)
584 newcapacity = bumped;
622 return (inclusive ?
sizeof(*
this) : 0) +
capacity()*
sizeof(
T);
633 if (newsize == mySize)
636 if (mySize > newsize)
644 if (
size() >= minsize)
662 if (newsize == mySize)
665 if (mySize > newsize)
675 if (maxsize >= 0 &&
size() > maxsize)
756 return (i >= 0 && i < mySize) ? myData[i] :
T();
762 return myData[mySize-1];
767 return myData[mySize-1];
776 template <
typename BinaryOp>
783 const T *
array()
const {
return myData; }
786 const T *
data()
const {
return myData; }
791 {
T *
data = myData; myData = newdata;
return data; }
793 template <
typename IT,
bool FORWARD>
795 public std::iterator<std::random_access_iterator_tag, T, exint>
807 template<
typename EIT>
809 : myCurrent(src.myCurrent), myEnd(src.myEnd) {}
812 {
return FORWARD ? myCurrent : myCurrent - 1; }
815 {
return FORWARD ? *myCurrent : myCurrent[-1]; }
818 {
return FORWARD ? *myCurrent : myCurrent[-1]; }
821 {
return FORWARD ? myCurrent[
n] : myCurrent[-n - 1]; }
826 if (FORWARD) ++myCurrent;
else --myCurrent;
833 if (FORWARD) ++myCurrent;
else --myCurrent;
839 if (FORWARD) --myCurrent;
else ++myCurrent;
846 if (FORWARD) --myCurrent;
else ++myCurrent;
867 {
return (*
this) += (-
n); }
869 {
return (*
this) + (-
n); }
871 bool atEnd()
const {
return myCurrent == myEnd; }
875 template<
typename ITR,
bool FR>
877 {
return myCurrent == r.myCurrent; }
879 template<
typename ITR,
bool FR>
881 {
return myCurrent != r.myCurrent; }
883 template<
typename ITR>
884 bool operator<(const base_iterator<ITR, FORWARD> &
r)
const
887 return myCurrent <
r.myCurrent;
889 return r.myCurrent < myCurrent;
892 template<
typename ITR>
896 return myCurrent > r.myCurrent;
898 return r.myCurrent > myCurrent;
901 template<
typename ITR>
902 bool operator<=(const base_iterator<ITR, FORWARD> &
r)
const
905 return myCurrent <=
r.myCurrent;
907 return r.myCurrent <= myCurrent;
910 template<
typename ITR>
914 return myCurrent >= r.myCurrent;
916 return r.myCurrent >= myCurrent;
920 template<
typename ITR>
924 return exint(myCurrent - r.myCurrent);
926 return exint(r.myCurrent - myCurrent);
949 return iterator(myData, myData + mySize);
1007 removeAt(&it.item() - myData);
1016 myData = src.myData;
1017 myCapacity = src.myCapacity;
1018 mySize = src.mySize;
1023 myCapacity = srcsize;
1042 return (myData != (
T *)(((
char*)
this) +
sizeof(*
this)));
1046 return (data != (
T *)(((
char*)
this) +
sizeof(*
this)));
1056 return SYS_IsPod_v< T >;
1062 template <
typename S>
1066 template <
typename S>
1069 template <
typename S>
1075 template <typename First, typename... Rest>
1079 static_cast<const void *>(&first) <
1080 static_cast<const void *>(myData) ||
1081 static_cast<const void *>(&first) >=
1082 static_cast<const void *>(myData + mySize),
1083 "Argument cannot reference an existing element in the array.");
1094 template <
typename...
S>
1097 new (&
dst)
T(std::forward<S>(
s)...);
1114 relocateNonoverlapping(dst, src, n);
1119 for (
exint i = 0; i <
n; i++)
1120 new (&dst[i])
T(src[i]);
1130 memset((
void *)&dst, 0,
sizeof(
T));
1136 for (
exint i = 0; i <
n; i++)
1148 memset((
void *)dst, 0,
sizeof(
T));
1151 memset((
void *)dst, 0,
sizeof(
T) * n);
1164 for (
exint i = 0; i <
n; i++)
1173 class AppendIterator
1174 :
public std::iterator<std::output_iterator_tag, void, void, void, void>
1177 explicit AppendIterator(
UT_Array<T> &arr) : myArray(&arr) {}
1183 myArray->append(val);
1189 myArray->append(std::move(val));
1196 AppendIterator &
operator*() {
return *
this; }
1197 AppendIterator &operator++() {
return *
this; }
1198 AppendIterator operator++(
int) {
return *
this; }
1214 static void relocateNonoverlapping(
T *
dst,
const T *
src,
exint n) noexcept
1216 ::memcpy((
void*)
dst, (
const void*)
src,
n *
sizeof(
T));
1221 ::memmove((
void*)
dst, (
const void*)
src,
n *
sizeof(
T));
1229 template<
typename OS,
typename S>
1230 friend OS &operator<<(OS &os, const UT_Array<S> &d);
1240 template <
typename T,
typename S>
1247 for (
exint i = 0; i <
n; i++)
1248 dest(i) =
T(
src(i));
1250 template <
typename T,
typename S>
1256 for (
exint i = 0; i <
n; i++)
1257 dest(i) =
T(src[i]);
1259 template <
typename T,
typename S>
1265 for (
exint i = 0; i <
n; i++)
1266 dest[i] =
T(
src(i));
1268 template <
typename T,
typename S>
1273 for (
int64 i = 0; i <
n; i++)
1274 dest[i] =
T(src[i]);
1280 template<
typename OS,
typename S>
1282 operator<<(OS &os, const UT_Array<S> &d)
1289 template <
typename T>
UT_API size_t
1294 template <
template <
typename>
class ArrayT,
typename T>
1296 UTarrayDeepMemoryUsage(
const ArrayT<T> &arr,
bool inclusive)
1298 int64 mem = inclusive ?
sizeof(arr) : 0;
1299 mem += arr.getMemoryUsage(
false);
1300 for (
auto &&item : arr)
1301 mem += item.getMemoryUsage(
false);
1306 template <
typename T>
1310 arr.
sort([](
const T &
a,
const T &
b) {
return a <
b; });
1314 template <
typename T>
1324 template <
typename T>
1325 struct DefaultClearer;
1327 template <
typename T>
1336 static const bool clearNeedsDestruction =
false;
1340 #endif // __UT_ARRAY_H_INCLUDED__
reference operator*() const
base_iterator & operator++()
Pre-increment operator.
int isEqual(const UT_Array< T > &a, Comparator compare) const
base_iterator & operator--()
Pre-decrement operator.
exint insert(T &&t, exint i)
IndexedCompare(const UT_Array< V > &values, const ComparatorBool &compare)
GLboolean GLboolean GLboolean b
const T & operator[](exint i) const
void merge(const UT_Array< T > &other, int direction, bool allow_dups, ComparatorBool is_less={})
const T * getRawArray() const
bool isHeapBuffer() const
Returns true if the data used by the array was allocated on the heap.
pointer operator->() const
base_iterator operator+(exint n) const
GLenum GLuint GLsizei bufsize
void validateEmplaceArgs() const
Base case for validateEmplaceArgs().
bool operator!=(const UT_Array< T > &a) const
void stableSort(ComparatorBool is_less={})
void setSizeIfNeeded(exint minsize)
exint insertImpl(S &&s, exint index)
Similar to appendImpl() but for insertion.
static void copyConstructRange(T *dst, const T *src, exint n)
SYS_FORCE_INLINE void removeLast()
void unsafeShareData(T *src, exint size, exint capacity)
exint findAndRemove(const S &s)
UT_Array< T > & operator=(const UT_Array< T > &a)
IMF_EXPORT IMATH_NAMESPACE::V3f direction(const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &pixelPosition)
void extractRange(exint begin_i, exint end_i, UT_Array< T > &dest)
void collapseIf(IsEqual is_equal)
Remove all matching elements. Also sets the capacity of the array.
T * aliasArray(T *newdata)
void setSizeNoInit(exint newsize)
bool isValidIndex(exint index) const
Return true if given index is valid.
#define SYS_DEPRECATED_HDK_REPLACE(__V__, __R__)
void zero()
Zeros the array if a POD type, else trivial constructs if a class type.
base_iterator< const T, false > const_reverse_iterator
static void trivialConstruct(T &dst)
Element Constructor.
friend void swap(UT_Array< T > &a, UT_Array< T > &b)
UT_API size_t format(char *buffer, size_t bufsize, const UT_Array< T > &v)
exint uniqueSortedFind(const T &item, ComparatorBool is_less={}) const
void move(exint src_idx, exint dst_idx, exint how_many)
const_iterator begin() const
int64 getMemoryUsage(bool inclusive=false) const
void bumpEntries(exint newsize)
const T & heapMax() const
void cycle(exint how_many)
Cyclically shifts the entire array by how_many.
exint removeIndex(exint index)
const_reverse_iterator rend() const
End reverse iterator. Consider using it.atEnd() instead.
bool isHeapBuffer(T *data) const
static constexpr SYS_FORCE_INLINE bool isPOD()
exint concat(const UT_Array< T > &a)
Takes another T array and concatenate it onto my end.
exint append(const T &t, bool check_dup)
#define UT_ASSERT_MSG_P(ZZ,...)
exint index(const T &t) const
bool operator>=(const base_iterator< ITR, FORWARD > &r) const
exint uniqueSortedInsert(const T &t, Comparator compare)
exint find(const S &s, exint start=0) const
void bumpCapacity(exint mincapacity)
static bool isClear(const UT_Array< T > &v)
void setSize(exint newsize)
bool operator==(const base_iterator< ITR, FR > &r) const
static void trivialDestructRange(T *dst, exint n)
void sortedUnion(const UT_Array< T > &other, ComparatorBool is_less={})
base_iterator operator-(exint n) const
void bumpSize(exint newsize)
bool operator>(const base_iterator< ITR, FORWARD > &r) const
base_iterator< T, false > reverse_iterator
void unsafeShareData(T *src, exint srcsize)
GLenum GLsizei GLsizei GLint * values
#define SYS_DEPRECATED_REPLACE(__V__, __R__)
exint operator-(const base_iterator< ITR, FORWARD > &r) const
exint sortAndRemoveDuplicates(ComparatorBool is_less={})
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, ROI roi={}, int nthreads=0)
const_reverse_iterator rbegin() const
Begin iterating over the array in reverse.
exint safeIndex(const T &t) const
void setCapacity(exint newcapacity)
void stableSortByKey(const UT_Array< K > &keys, ComparatorBool is_less)
exint apply(int(*apply_func)(T &t, void *d), void *d)
reverse_iterator rbegin()
Begin iterating over the array in reverse.
exint emplace_back(S &&...s)
static void construct(T &dst, S &&...s)
void entries(exint newsize)
Alias of setSize(). setSize() is preferred.
exint uniqueSortedInsertImpl(S &&s, Comparator compare)
const T & operator()(exint i) const
void sort(ComparatorBool is_less={})
Sort using std::sort with bool comparator. Defaults to operator<().
reference operator[](exint n) const
exint insertAt(const T &t, exint index)
T accumulate(const T &init_value, BinaryOp add) const
GLboolean GLboolean GLboolean GLboolean a
base_iterator< T, true > iterator
GLsizei GLenum const void * indices
static void clearConstruct(UT_Array< T > *p)
static SYS_FORCE_INLINE void trivialDestruct(T &dst)
Element Destructor.
exint sortedInsert(const T &t, Comparator compare)
UT_IteratorRange< reverse_iterator > rrange()
exint insert(const T &t, exint i)
base_iterator(const base_iterator< EIT, FORWARD > &src)
void appendMultiple(const T &t, exint count)
static void trivialConstructRange(T *dst, exint n)
IMATH_HOSTDEVICE constexpr Color4< T > operator*(S a, const Color4< T > &v) IMATH_NOEXCEPT
Reverse multiplication: S * Color4.
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
base_iterator(IT *c, IT *e)
void stableSortRange(ComparatorBool is_less, exint start, exint end)
Like stableSort, but operates on a subset of the array.
T forcedGet(exint i) const
static void copyConstruct(T &dst, const T &src)
#define SYS_DEPRECATED_HDK(__V__)
exint removeIf(IsEqual is_equal)
const_iterator end() const
End const iterator. Consider using it.atEnd() instead.
base_iterator & operator-=(exint n)
exint sortedRemoveDuplicates()
void sortedSetDifference(const UT_Array< T > &other, ComparatorBool is_less={})
void unsafeShareData(UT_Array< T > &src)
reverse_iterator rend()
End reverse iterator.
bool operator()(I a, I b) const
bool operator!=(const base_iterator< ITR, FR > &r) const
exint sortedRemoveDuplicatesIf(CompareEqual compare_equal)
exint entries() const
Alias of size(). size() is preferred.
T selectNthLargest(exint idx, ComparatorBool is_less={})
base_iterator & operator+=(exint n)
void stdsort(ComparatorBool is_less)
Sort using std::sort. The ComparatorBool uses the less-than semantics.
UT_Array(exint capacity=0)
Construct based on given capacity with a size of 0.
base_iterator operator--(int)
Post-decrement operator.
static void clear(UT_Array< T > &v)
int(* Comparator)(const T *, const T *)
base_iterator< const T, true > const_iterator
void stableArgSort(UT_Array< I > &indices, ComparatorBool is_less) const
void truncate(exint maxsize)
Decreases, but never expands, to the given maxsize.
void constant(const T &v)
Quickly set the array to a single value.
void setCapacityIfNeeded(exint mincapacity)
void removeItem(const reverse_iterator &it)
Remove item specified by the reverse_iterator.
void sortedIntersection(const UT_Array< T > &other, ComparatorBool is_less={})
void UTconvertArray(UT_Array< T > &dest, const UT_Array< S > &src)
Comparator class for stableSortIndices.
ImageBuf OIIO_API add(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
UT_Array(const UT_Array< T > &a)
void clear()
Resets list to an empty list.
void stableSortIndices(UT_Array< I > &indices, ComparatorBool is_less) const
UT_IteratorRange< iterator > range()
UT_IteratorRange< const_iterator > range() const
GA_API const UT_StringHolder rest
T heapPop(Comparator compare)
exint heapPush(const T &t, Comparator compare)
void sort(I begin, I end, const Pred &pred)
void reverse()
Reverses the array by swapping elements in mirrored locations.
exint multipleInsert(exint index, exint count)
Insert an element "count" times at the given index. Return the index.
void removeRange(exint begin_i, exint end_i)
base_iterator operator++(int)
Post-increment operator.
void swap(UT_Array< T > &other)
exint insert(exint index)
bool hasSortedSubset(const UT_Array< T > &other, ComparatorBool is_less={}) const
iterator end()
End iterator.
UT_IteratorRange< const_reverse_iterator > rrange() const
bool isEmpty() const
Returns true iff there are no occupied elements in the array.
bool operator==(const UT_Array< T > &a) const
exint sortedFind(const T &t, Comparator compare) const