 |
ROOT
Reference Guide |
|
| |
ROOT
Reference Guide |
|
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.
Public Types | |
| using | const_iterator = typename SuperClass::const_iterator |
| using | const_pointer = const T * |
| using | const_reference = const T & |
| using | const_reverse_iterator = std::reverse_iterator<const_iterator> |
| using | difference_type = ptrdiff_t |
| using | iterator = typename SuperClass::iterator |
| using | pointer = T * |
| using | reference = typename SuperClass::reference |
| using | reverse_iterator = std::reverse_iterator<iterator> |
| using | Size_T = int32_t |
| using | size_type = typename SuperClass::size_type |
| using | value_type = T |
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. | |
| void | grow_pod (size_t MinSize, size_t TSize) |
| 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. | |
| bool | isSmall () const |
| Return true if this is a smallvector which has not had dynamic memory allocated for it. | |
| bool | Owns () const |
| If false, the RVec is in "memory adoption" mode, i.e. it is acting as a view on a memory buffer it does not own. | |
| void | resetToSmall () |
| Put this vector in a state of being small. | |
| void | SetSizeUnchecked (std::size_t N) |
Static Protected Member Functions | |
| static void | destroy_range (T *, T *) |
| static void | report_at_maximum_capacity () |
| Report that this vector is already at maximum capacity. | |
| static void | report_size_overflow (size_t MinSize) |
| Report that MinSize doesn't fit into this vector's size type. | |
| static constexpr size_t | SizeTypeMax () |
| The maximum value of the Size_T used. | |
| 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. | |
| template<typename T1 , typename T2 > | |
| static void | uninitialized_copy (T1 *I, T1 *E, T2 *Dest, typename std::enable_if< std::is_same< typename std::remove_const< T1 >::type, T2 >::value >::type *=nullptr) |
| Copy 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_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. | |
Protected Attributes | |
| void * | fBeginX |
| Size_T | fCapacity |
| Always >= -1. fCapacity == -1 indicates the RVec is in "memory adoption" mode. | |
| Size_T | fSize = 0 |
| Always >= 0. | |
Private Types | |
| using | Base = SmallVectorBase |
| using | SuperClass = SmallVectorTemplateCommon<T> |
Private Member Functions | |
| void * | getFirstEl () const |
| Find the address of the first element. | |
#include <ROOT/RVec.hxx>
|
privateinherited |
| using ROOT::Internal::VecOps::SmallVectorTemplateBase< T, true >::const_iterator = typename SuperClass::const_iterator |
|
inherited |
|
inherited |
|
inherited |
|
inherited |
| using ROOT::Internal::VecOps::SmallVectorTemplateBase< T, true >::iterator = typename SuperClass::iterator |
|
inherited |
| using ROOT::Internal::VecOps::SmallVectorTemplateBase< T, true >::reference = typename SuperClass::reference |
|
inherited |
|
inherited |
| using ROOT::Internal::VecOps::SmallVectorTemplateBase< T, true >::size_type = typename SuperClass::size_type |
|
private |
|
inherited |
|
inlineprotected |
|
inlineinherited |
|
inlineinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlineinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinestaticprotected |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlineinherited |
|
inlineinherited |
|
inlineprivateinherited |
Find the address of the first element.
For this pointer math to be valid with small-size of 0 for T with lots of alignment, it's important that SmallVectorStorage is properly-aligned even for small-size of 0.
|
inlineprotected |
|
inlineprotectedinherited |
|
inlineprotectedinherited |
|
inlinenoexceptinherited |
|
inlineprotectedinherited |
|
inline |
|
inline |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
inlinenoexceptinherited |
|
staticprotectedinherited |
|
staticprotectedinherited |
|
inlineprotectedinherited |
|
inlineinherited |
Set the array size to N, which the current array must have enough capacity for.
This does not construct or destroy any elements in the vector.
Clients can use this in conjunction with capacity() to write past the end of the buffer when they know that more elements are available, and only update the size later. This avoids the cost of value initializing elements which will only be overwritten.
|
inlineprotectedinherited |
|
inlineinherited |
|
inlineinherited |
|
protectedinherited |
|
protectedinherited |
|
protectedinherited |
