LLVM: llvm::SmallVectorTemplateBase< T, true > Class Template Reference (original) (raw)
SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's. More...
#include "[llvm/ADT/SmallVector.h](SmallVector%5F8h%5Fsource.html)"
| Protected Types | |
|---|---|
| using | ValueParamT = std::conditional_t<TakesParamByValue, T, const T &> |
| Either const T& or T, depending on whether it's cheap enough to take parameters by value. |
| Protected Member Functions | |
|---|---|
| SmallVectorTemplateBase (size_t Size) | |
| void | grow (size_t MinSize=0) |
| Double the size of the allocated memory, guaranteeing space for at least one more element or MinSize if specified. | |
| const T * | reserveForParamAndGetAddress (const T &Elt, size_t N=1) |
| Reserve enough space to add one element, and return the updated element pointer in case it was a reference to the storage. | |
| T * | reserveForParamAndGetAddress (T &Elt, size_t N=1) |
| Reserve enough space to add one element, and return the updated element pointer in case it was a reference to the storage. | |
| void | growAndAssign (size_t NumElts, T Elt) |
| template<typename... ArgTypes> | |
| T & | growAndEmplaceBack (ArgTypes &&... Args) |
| T * | mallocForGrow (size_t MinSize, size_t &NewCapacity) |
| Create a new allocation big enough for MinSize and pass back its size in NewCapacity. | |
| void | moveElementsForGrow (T *NewElts) |
| Move existing elements over to the new allocation NewElts, the middle section of grow(). | |
| void | takeAllocationForGrow (T *NewElts, size_t NewCapacity) |
| Transfer ownership of the allocation, finishing up grow(). | |
| Protected Member Functions inherited from llvm::SmallVectorTemplateCommon< T, typename > | |
| void * | getFirstEl () const |
| Find the address of the first element. | |
| SmallVectorTemplateCommon (size_t Size) | |
| void | grow_pod (size_t MinSize, size_t TSize) |
| bool | isSmall () const |
| Return true if this is a smallvector which has not had dynamic memory allocated for it. | |
| void | resetToSmall () |
| Put this vector in a state of being small. | |
| bool | isReferenceToRange (const void *V, const void *First, const void *Last) const |
| Return true if V is an internal reference to the given range. | |
| bool | isReferenceToStorage (const void *V) const |
| Return true if V is an internal reference to this vector. | |
| bool | isRangeInStorage (const void *First, const void *Last) const |
| Return true if First and Last form a valid (possibly empty) range in this vector's storage. | |
| bool | isSafeToReferenceAfterResize (const void *Elt, size_t NewSize) |
| Return true unless Elt will be invalidated by resizing the vector to NewSize. | |
| void | assertSafeToReferenceAfterResize (const void *Elt, size_t NewSize) |
| Check whether Elt will be invalidated by resizing the vector to NewSize. | |
| void | assertSafeToAdd (const void *Elt, size_t N=1) |
| Check whether Elt will be invalidated by increasing the size of the vector by N. | |
| template<class ItTy> | |
| void | assertSafeToReferenceAfterClear (ItTy From, ItTy To) |
| Check whether any part of the range will be invalidated by clearing. | |
| template<class ItTy> | |
| void | assertSafeToAddRange (ItTy From, ItTy To) |
| Check whether any part of the range will be invalidated by growing. | |
| Protected Member Functions inherited from llvm::SmallVectorBase< SmallVectorSizeType< T > > | |
| SmallVectorBase ()=delete | |
| SmallVectorBase (void *FirstEl, size_t TotalCapacity) | |
| LLVM_ABI void * | mallocForGrow (void *FirstEl, size_t MinSize, size_t TSize, size_t &NewCapacity) |
| This is a helper for grow() that's out of line to reduce code duplication. | |
| LLVM_ABI void | grow_pod (void *FirstEl, size_t MinSize, size_t TSize) |
| This is an implementation of the grow() method which only works on POD-like data types and is out of line to reduce code duplication. | |
| void | set_size (size_t N) |
| Set the array size to N, which the current array must have enough capacity for. | |
| void | set_allocation_range (void *Begin, size_t N) |
| Set the array data pointer to Begin and capacity to N. |
| Static Protected Member Functions | |
|---|---|
| static void | destroy_range (T *, T *) |
| template<typename It1, typename It2> | |
| static void | uninitialized_move (It1 I, It1 E, It2 Dest) |
| Move the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into it as needed. | |
| template<typename It1, typename It2> | |
| static void | uninitialized_copy (It1 I, It1 E, It2 Dest) |
| Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into it as needed. | |
| static ValueParamT | forward_value_param (ValueParamT V) |
| Copy V or return a reference, depending on ValueParamT. | |
| Static Protected Member Functions inherited from llvm::SmallVectorTemplateCommon< T, typename > | |
| template | |
| static const T * | reserveForParamAndGetAddressImpl (U *This, const T &Elt, size_t N) |
| Reserve enough space to add one element, and return the updated element pointer in case it was a reference to the storage. | |
| Static Protected Member Functions inherited from llvm::SmallVectorBase< SmallVectorSizeType< T > > | |
| static constexpr size_t | SizeTypeMax () |
| The maximum value of the Size_T used. |
| Static Protected Attributes | |
|---|---|
| static constexpr bool | TakesParamByValue = sizeof(T) <= 2 * sizeof(void *) |
| True if it's cheap enough to take parameters by value. |
| Additional Inherited Members | |
|---|---|
| Public Types inherited from llvm::SmallVectorTemplateCommon< T, typename > | |
| using | size_type = size_t |
| using | difference_type = ptrdiff_t |
| using | value_type = T |
| using | iterator = T * |
| using | const_iterator = const T * |
| using | const_reverse_iterator = std::reverse_iterator<const_iterator> |
| using | reverse_iterator = std::reverse_iterator<iterator> |
| using | reference = T & |
| using | const_reference = const T & |
| using | pointer = T * |
| using | const_pointer = const T * |
| Protected Attributes inherited from llvm::SmallVectorBase< SmallVectorSizeType< T > > | |
| void * | BeginX |
| SmallVectorSizeType< T > | Size |
| SmallVectorSizeType< T > | Capacity |
template<typename T>
class llvm::SmallVectorTemplateBase< T, true >
SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's.
This allows using memcpy in place of copy/move construction and skipping destruction.
Definition at line 479 of file SmallVector.h.
◆ ValueParamT
Either const T& or T, depending on whether it's cheap enough to take parameters by value.
Definition at line 489 of file SmallVector.h.
◆ destroy_range()
◆ forward_value_param()
Copy V or return a reference, depending on ValueParamT.
Definition at line 542 of file SmallVector.h.
◆ grow()
◆ growAndAssign()
◆ growAndEmplaceBack()
template<typename T>
template<typename... ArgTypes>
◆ mallocForGrow()
Create a new allocation big enough for MinSize and pass back its size in NewCapacity.
This is the first section of grow().
Definition at line 370 of file SmallVector.h.
◆ moveElementsForGrow()
Move existing elements over to the new allocation NewElts, the middle section of grow().
Definition at line 374 of file SmallVector.h.
◆ pop_back()
◆ push_back()
◆ reserveForParamAndGetAddress() [1/2]
◆ reserveForParamAndGetAddress() [2/2]
◆ takeAllocationForGrow()
Transfer ownership of the allocation, finishing up grow().
Definition at line 377 of file SmallVector.h.
◆ uninitialized_copy()
template<typename T>
template<typename It1, typename It2>
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into it as needed.
Definition at line 507 of file SmallVector.h.
◆ uninitialized_move()
template<typename T>
template<typename It1, typename It2>
◆ SmallVectorTemplateCommon< T >
◆ TakesParamByValue
True if it's cheap enough to take parameters by value.
Doing so avoids overhead related to mitigations for reference invalidation.
Definition at line 485 of file SmallVector.h.
The documentation for this class was generated from the following file:
- include/llvm/ADT/SmallVector.h