template<
typename T, unsigned
int N>
class ROOT::VecOps::RVecN< T, N >
Definition at line 1157 of file RVec.hxx.
|
| | RVecN () |
| |
| | RVecN (const RVecN &RHS) |
| |
| | RVecN (const std::vector< T > &RHS) |
| |
| | RVecN (Detail::VecOps::RVecImpl< T > &&RHS) |
| |
| template<typename ItTy , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<ItTy>::iterator_category, std::input_iterator_tag>::value>::type> |
| | RVecN (ItTy S, ItTy E) |
| |
| | RVecN (RVecN &&RHS) noexcept(false) |
| |
| | RVecN (size_t Size) |
| |
| | RVecN (size_t Size, const T &Value) |
| |
| | RVecN (std::initializer_list< T > IL) |
| |
| | RVecN (T *p, size_t n) |
| |
| | ~RVecN () |
| |
| template<typename in_iter , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<in_iter>::iterator_category, std::input_iterator_tag>::value>::type> |
| void | append (in_iter in_start, in_iter in_end) |
| | Add the specified range to the end of the SmallVector.
|
| |
| void | append (size_type NumInputs, const T &Elt) |
| | Append NumInputs copies of Elt to the end.
|
| |
| void | append (std::initializer_list< T > IL) |
| |
| template<typename in_iter , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<in_iter>::iterator_category, std::input_iterator_tag>::value>::type> |
| void | assign (in_iter in_start, in_iter in_end) |
| |
| void | assign (size_type NumElts, const T &Elt) |
| |
| void | assign (std::initializer_list< T > IL) |
| |
| reference | at (size_type pos) |
| |
| const_reference | at (size_type pos) const |
| |
| value_type | at (size_type pos, value_type fallback) |
| | No exception thrown. The user specifies the desired value in case the RVecN is shorter than pos.
|
| |
| value_type | at (size_type pos, value_type fallback) const |
| | No exception thrown. The user specifies the desired value in case the RVecN is shorter than pos.
|
| |
| reference | back () |
| |
| const_reference | back () const |
| |
| const_iterator | begin () const noexcept |
| |
| iterator | begin () noexcept |
| |
| size_t | capacity () const noexcept |
| |
| size_t | capacity_in_bytes () const |
| |
| const_iterator | cbegin () const noexcept |
| |
| const_iterator | cend () const noexcept |
| |
| void | clear () |
| |
| const_reverse_iterator | crbegin () const noexcept |
| |
| const_reverse_iterator | crend () const noexcept |
| |
| const_pointer | data () const noexcept |
| | Return a pointer to the vector's buffer, even if empty().
|
| |
| pointer | data () noexcept |
| | Return a pointer to the vector's buffer, even if empty().
|
| |
| template<typename... ArgTypes> |
| reference | emplace_back (ArgTypes &&...Args) |
| |
| bool | empty () const |
| |
| const_iterator | end () const noexcept |
| |
| iterator | end () noexcept |
| |
| iterator | erase (const_iterator CI) |
| |
| iterator | erase (const_iterator CS, const_iterator CE) |
| |
| reference | front () |
| |
| const_reference | front () const |
| |
| iterator | insert (iterator I, const T &Elt) |
| |
| template<typename ItTy , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<ItTy>::iterator_category, std::input_iterator_tag>::value>::type> |
| iterator | insert (iterator I, ItTy From, ItTy To) |
| |
| iterator | insert (iterator I, size_type NumToInsert, const T &Elt) |
| |
| void | insert (iterator I, std::initializer_list< T > IL) |
| |
| iterator | insert (iterator I, T &&Elt) |
| |
| size_type | max_size () const noexcept |
| |
| template<typename U , unsigned M, typename = std::enable_if<std::is_convertible<T, U>::value>> |
| | operator RVecN< U, M > () const |
| |
| RVecN & | operator= (const RVecN &RHS) |
| |
| RVecN & | operator= (Detail::VecOps::RVecImpl< T > &&RHS) |
| |
| RVecN & | operator= (RVecN &&RHS) noexcept(std::is_nothrow_move_assignable_v< Detail::VecOps::RVecImpl< T > >) |
| |
| RVecN & | operator= (std::initializer_list< T > IL) |
| |
| template<typename V , unsigned M, typename = std::enable_if<std::is_convertible<V, bool>::value>> |
| RVecN | operator[] (const RVecN< V, M > &conds) const |
| |
| reference | operator[] (size_type idx) |
| |
| const_reference | operator[] (size_type idx) const |
| |
| void | pop_back () |
| |
| void | pop_back_n (size_type NumItems) |
| |
| T | pop_back_val () |
| |
| void | push_back (const T &Elt) |
| |
| void | push_back (T &&Elt) |
| |
| const_reverse_iterator | rbegin () const noexcept |
| |
| reverse_iterator | rbegin () noexcept |
| |
| const_reverse_iterator | rend () const noexcept |
| |
| reverse_iterator | rend () noexcept |
| |
| void | reserve (size_type N) |
| |
| void | resize (size_type N) |
| |
| void | resize (size_type N, const T &NV) |
| |
| void | set_size (size_t N) |
| | Set the array size to N, which the current array must have enough capacity for.
|
| |
| size_t | size () const |
| |
| size_type | size_in_bytes () const |
| |
| void | swap (RVecImpl &RHS) |
| |
|
| void | grow (size_t MinSize=0) |
| | Grow the allocated memory (without initializing new elements), doubling the size of the allocated memory.
|
| |
| 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 void | destroy_range (T *S, T *E) |
| |
| 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 as needed.
|
| |
| template<typename It1 , typename It2 > |
| static void | uninitialized_move (It1 I, It1 E, It2 Dest) |
| | Move the range [I, E) into the uninitialized memory starting with "Dest", constructing elements as needed.
|
| |
| void ROOT::Internal::VecOps::SmallVectorBase::set_size |
( |
size_t | N | ) |
|
|
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.
Definition at line 192 of file RVec.hxx.
