PCL
pcl::IndirectSortedArray< T, A > Class Template Reference

Generic dynamic sorted array of pointers to objects. More...

#include <IndirectSortedArray.h>

+ Inheritance diagram for pcl::IndirectSortedArray< T, A >:

Public Types

typedef array_implementation::allocator allocator
 
typedef IndirectArray< T, A > array_implementation
 
typedef array_implementation::block_allocator block_allocator
 
typedef array_implementation::const_iterator const_iterator
 
typedef array_implementation::const_reverse_iterator const_reverse_iterator
 
typedef array_implementation::equal equal
 
typedef array_implementation::iterator iterator
 
typedef array_implementation::less less
 
typedef array_implementation::reverse_iterator reverse_iterator
 

Public Member Functions

 IndirectSortedArray ()
 
 IndirectSortedArray (size_type n)
 
 IndirectSortedArray (size_type n, const T *p)
 
template<class FI >
 IndirectSortedArray (FI i, FI j)
 
 IndirectSortedArray (const IndirectSortedArray &x)
 
 IndirectSortedArray (IndirectSortedArray &&x)
 
 ~IndirectSortedArray ()
 
void Add (const IndirectSortedArray &x)
 
void Add (const IndirectArray< T, A > &x)
 
const_iterator Add (const T *p, size_type n=1)
 
template<class FI >
void Add (FI i, FI j)
 
template<class F >
void Apply (F f) const
 
void Assign (const IndirectSortedArray &x)
 
void Assign (const array_implementation &x)
 
void Assign (const T *p, size_type n=1)
 
template<class FI >
void Assign (FI i, FI j)
 
const_iterator At (size_type i) const
 
size_type Available () const
 
const_iterator Begin () const
 
const_iterator begin () const
 
size_type Capacity () const
 
void Clear ()
 
template<class C >
void CloneAssign (const C &x)
 
void CloneAssign (SortedArray< T, A > &x)
 
void CloneAssign (IndirectSortedArray &x)
 
bool Contains (const T &v) const
 
bool Contains (const T *p) const
 
template<class BP >
bool Contains (const T &v, BP p) const
 
size_type Count (const T &v) const
 
size_type Count (const T *p) const
 
template<class BP >
size_type Count (const T &v, BP p) const
 
template<class UP >
size_type CountIf (UP p) const
 
void Delete (iterator i, size_type n=1)
 
void Delete (iterator i, iterator j)
 
void Delete (const T &v)
 
template<class BP >
void Delete (const T &v, BP p)
 
void Delete ()
 
void Destroy (iterator i, size_type n=1)
 
void Destroy (iterator i, iterator j)
 
void Destroy (const T &v)
 
template<class BP >
void Destroy (const T &v, BP p)
 
void Destroy ()
 
const_iterator End () const
 
const_iterator end () const
 
void EnsureUnique ()
 
void Fill (const T &v)
 
const T * First () const
 
template<class F >
const_iterator FirstThat (F f) const
 
const allocatorGetAllocator () const
 
uint64 Hash (uint64 seed=0) const
 
uint32 Hash32 (uint32 seed=0) const
 
uint64 Hash64 (uint64 seed=0) const
 
void Import (iterator i, iterator j)
 
bool IsAliasOf (const IndirectSortedArray &x) const
 
bool IsEmpty () const
 
bool IsUnique () const
 
bool IsValid () const
 
const T * Last () const
 
template<class F >
const_iterator LastThat (F f) const
 
size_type Length () const
 
size_type LowerBound () const
 
const_iterator MaxItem () const
 
template<class BP >
const_iterator MaxItem (BP p) const
 
const_iterator MinItem () const
 
template<class BP >
const_iterator MinItem (BP p) const
 
iterator MutableAt (size_type i)
 
iterator MutableBegin ()
 
iterator MutableEnd ()
 
T * MutableFirst ()
 
iterator MutableIterator (const_iterator i)
 
T * MutableLast ()
 
reverse_iterator MutableReverseBegin ()
 
reverse_iterator MutableReverseEnd ()
 
const T * operator* () const
 
IndirectSortedArrayoperator= (const IndirectSortedArray &x)
 
IndirectSortedArrayoperator= (IndirectSortedArray &&x)
 
IndirectSortedArrayoperator= (const array_implementation &x)
 
IndirectSortedArrayoperator= (array_implementation &&x)
 
const T * operator[] (size_type i) const
 
void Pack ()
 
iterator Release ()
 
void Remove (const_iterator i, size_type n=1)
 
void Remove (const_iterator i, const_iterator j)
 
void Remove (const T &v)
 
template<class BP >
void Remove (const T &v, BP p)
 
void Remove (const T *p)
 
void Reserve (size_type n)
 
const_reverse_iterator ReverseBegin () const
 
const_reverse_iterator ReverseEnd () const
 
const_iterator Search (const T &v) const
 
const_iterator Search (const T *p) const
 
template<class BP >
const_iterator Search (const T &v, BP p) const
 
const_iterator SearchLast (const T &v) const
 
const_iterator SearchLast (const T *p) const
 
template<class BP >
const_iterator SearchLast (const T &v, BP p) const
 
void SetAllocator (const allocator &a)
 
void Shrink (size_type n=1)
 
size_type Size () const
 
void Sort ()
 
void Squeeze ()
 
template<class S >
S & ToCommaSeparated (S &s) const
 
template<class S , typename SP >
S & ToSeparated (S &s, SP separator) const
 
template<class S , typename SP , class AF >
S & ToSeparated (S &s, SP separator, AF append) const
 
template<class S >
S & ToSpaceSeparated (S &s) const
 
template<class S >
S & ToTabSeparated (S &s) const
 
void Transfer (IndirectSortedArray &x)
 
void Transfer (IndirectSortedArray &&x)
 
void Transfer (array_implementation &x)
 
void Transfer (array_implementation &&x)
 
void Truncate (const_iterator i)
 
void UniquifyIterator (iterator &i)
 
void UniquifyIterators (iterator &i, iterator &j)
 
size_type UpperBound () const
 

Friends

bool operator< (const IndirectSortedArray &x1, const IndirectSortedArray &x2)
 
bool operator< (const IndirectSortedArray &x1, const array_implementation &x2)
 
bool operator< (const array_implementation &x1, const IndirectSortedArray &x2)
 
bool operator== (const IndirectSortedArray &x1, const IndirectSortedArray &x2)
 
bool operator== (const IndirectSortedArray &x1, const array_implementation &x2)
 
bool operator== (const array_implementation &x1, const IndirectSortedArray &x2)
 
void Swap (IndirectSortedArray &x1, IndirectSortedArray &x2)
 

Detailed Description

template<class T, class A = StandardAllocator>
class pcl::IndirectSortedArray< T, A >

IndirectSortedArray is a generic, finite sorted sequence of pointers to objects, implemented as a reference-counted, dynamic array of T pointers with automatic sorting of inserted array elements. The type A provides dynamic allocation for contiguous sequences of void* elements (StandardAllocator is used by default).

Ordering of array elements is implemented by indirection, that is, the pointed-to objects are compared for sorting, not the contained pointers.

Unlike ReferenceArray and ReferenceSortedArray, IndirectSortedArray can contain null pointers, which are ignored automatically in all internal operations controlling the implicit ordering of the (indirectly) contained elements.

See also
IndirectArray, ReferenceArray, ReferenceSortedArray, Array, SortedArray, ReferenceCounter

Definition at line 91 of file IndirectSortedArray.h.

Member Typedef Documentation

◆ allocator

template<class T, class A = StandardAllocator>
typedef array_implementation::allocator pcl::IndirectSortedArray< T, A >::allocator

#

Definition at line 107 of file IndirectSortedArray.h.

◆ array_implementation

template<class T, class A = StandardAllocator>
typedef IndirectArray<T,A> pcl::IndirectSortedArray< T, A >::array_implementation

#

Definition at line 97 of file IndirectSortedArray.h.

◆ block_allocator

template<class T, class A = StandardAllocator>
typedef array_implementation::block_allocator pcl::IndirectSortedArray< T, A >::block_allocator

#

Definition at line 102 of file IndirectSortedArray.h.

◆ const_iterator

template<class T, class A = StandardAllocator>
typedef array_implementation::const_iterator pcl::IndirectSortedArray< T, A >::const_iterator

#

Definition at line 117 of file IndirectSortedArray.h.

◆ const_reverse_iterator

template<class T, class A = StandardAllocator>
typedef array_implementation::const_reverse_iterator pcl::IndirectSortedArray< T, A >::const_reverse_iterator

#

Definition at line 127 of file IndirectSortedArray.h.

◆ equal

template<class T, class A = StandardAllocator>
typedef array_implementation::equal pcl::IndirectSortedArray< T, A >::equal

#

Definition at line 132 of file IndirectSortedArray.h.

◆ iterator

template<class T, class A = StandardAllocator>
typedef array_implementation::iterator pcl::IndirectSortedArray< T, A >::iterator

#

Definition at line 112 of file IndirectSortedArray.h.

◆ less

template<class T, class A = StandardAllocator>
typedef array_implementation::less pcl::IndirectSortedArray< T, A >::less

#

Definition at line 137 of file IndirectSortedArray.h.

◆ reverse_iterator

template<class T, class A = StandardAllocator>
typedef array_implementation::reverse_iterator pcl::IndirectSortedArray< T, A >::reverse_iterator

#

Definition at line 122 of file IndirectSortedArray.h.

Constructor & Destructor Documentation

◆ IndirectSortedArray() [1/6]

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( )
inline

Constructs an empty indirect sorted array.

Definition at line 144 of file IndirectSortedArray.h.

◆ IndirectSortedArray() [2/6]

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( size_type  n)
inlineexplicit

Constructs an indirect sorted array of length n. All contained pointers are initialized to nullptr.

Definition at line 153 of file IndirectSortedArray.h.

◆ IndirectSortedArray() [3/6]

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( size_type  n,
const T *  p 
)
inline

Constructs an indirect sorted array that stores n copies of a pointer p.

Definition at line 161 of file IndirectSortedArray.h.

◆ IndirectSortedArray() [4/6]

template<class T, class A = StandardAllocator>
template<class FI >
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( FI  i,
FI  j 
)
inline

Constructs an indirect sorted array as a copy of the sequence of pointers defined by the range [i,j). The stored sequence of pointers is sorted by comparing the pointed objects.

Definition at line 171 of file IndirectSortedArray.h.

References pcl::Sort().

◆ IndirectSortedArray() [5/6]

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( const IndirectSortedArray< T, A > &  x)
inline

Copy constructor.

Definition at line 179 of file IndirectSortedArray.h.

◆ IndirectSortedArray() [6/6]

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::IndirectSortedArray ( IndirectSortedArray< T, A > &&  x)
inline

Move constructor.

Definition at line 186 of file IndirectSortedArray.h.

◆ ~IndirectSortedArray()

template<class T, class A = StandardAllocator>
pcl::IndirectSortedArray< T, A >::~IndirectSortedArray ( )
inline

Destroys an IndirectSortedArray object.

Deallocates the internal array of pointers to objects, but does not destroy the pointed objects. To destroy them, you have to call Destroy() or Delete() explicitly.

Definition at line 197 of file IndirectSortedArray.h.

Member Function Documentation

◆ Add() [1/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Add ( const IndirectSortedArray< T, A > &  x)
inline

◆ Add() [2/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Add ( const IndirectArray< T, A > &  x)
inline

#

Definition at line 622 of file IndirectSortedArray.h.

◆ Add() [3/4]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::Add ( const T *  p,
size_type  n = 1 
)
inline

#

Definition at line 629 of file IndirectSortedArray.h.

◆ Add() [4/4]

template<class T, class A = StandardAllocator>
template<class FI >
void pcl::IndirectSortedArray< T, A >::Add ( FI  i,
FI  j 
)
inline

#

Definition at line 637 of file IndirectSortedArray.h.

References pcl::InsertionPoint().

◆ Apply()

template<class T, class A = StandardAllocator>
template<class F >
void pcl::IndirectSortedArray< T, A >::Apply ( f) const
inline

#

Definition at line 868 of file IndirectSortedArray.h.

◆ Assign() [1/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Assign ( const IndirectSortedArray< T, A > &  x)
inline

#

Definition at line 485 of file IndirectSortedArray.h.

◆ Assign() [2/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Assign ( const array_implementation x)
inline

#

Definition at line 523 of file IndirectSortedArray.h.

References pcl::Sort().

◆ Assign() [3/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Assign ( const T *  p,
size_type  n = 1 
)
inline

#

Definition at line 555 of file IndirectSortedArray.h.

◆ Assign() [4/4]

template<class T, class A = StandardAllocator>
template<class FI >
void pcl::IndirectSortedArray< T, A >::Assign ( FI  i,
FI  j 
)
inline

#

Definition at line 563 of file IndirectSortedArray.h.

References pcl::Sort().

◆ At()

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::At ( size_type  i) const
inline

#

Definition at line 309 of file IndirectSortedArray.h.

◆ Available()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Available ( ) const
inline

#

Definition at line 260 of file IndirectSortedArray.h.

◆ Begin()

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::Begin ( ) const
inline

#

Definition at line 344 of file IndirectSortedArray.h.

◆ begin()

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::begin ( ) const
inline

STL-compatible iteration. Equivalent to Begin() const.

Definition at line 457 of file IndirectSortedArray.h.

◆ Capacity()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Capacity ( ) const
inline

#

Definition at line 253 of file IndirectSortedArray.h.

◆ Clear()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Clear ( )
inline

#

Definition at line 739 of file IndirectSortedArray.h.

◆ CloneAssign() [1/3]

template<class T, class A = StandardAllocator>
template<class C >
void pcl::IndirectSortedArray< T, A >::CloneAssign ( const C &  x)
inline

#

Definition at line 572 of file IndirectSortedArray.h.

◆ CloneAssign() [2/3]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::CloneAssign ( SortedArray< T, A > &  x)
inline

#

Definition at line 580 of file IndirectSortedArray.h.

◆ CloneAssign() [3/3]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::CloneAssign ( IndirectSortedArray< T, A > &  x)
inline

#

Definition at line 587 of file IndirectSortedArray.h.

◆ Contains() [1/3]

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::Contains ( const T &  v) const
inline

#

Definition at line 996 of file IndirectSortedArray.h.

◆ Contains() [2/3]

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::Contains ( const T *  p) const
inline

#

Definition at line 1003 of file IndirectSortedArray.h.

◆ Contains() [3/3]

template<class T, class A = StandardAllocator>
template<class BP >
bool pcl::IndirectSortedArray< T, A >::Contains ( const T &  v,
BP  p 
) const
inline

#

Definition at line 1011 of file IndirectSortedArray.h.

◆ Count() [1/3]

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Count ( const T &  v) const
inline

#

Definition at line 891 of file IndirectSortedArray.h.

◆ Count() [2/3]

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Count ( const T *  p) const
inline

#

Definition at line 899 of file IndirectSortedArray.h.

◆ Count() [3/3]

template<class T, class A = StandardAllocator>
template<class BP >
size_type pcl::IndirectSortedArray< T, A >::Count ( const T &  v,
BP  p 
) const
inline

#

Definition at line 907 of file IndirectSortedArray.h.

◆ CountIf()

template<class T, class A = StandardAllocator>
template<class UP >
size_type pcl::IndirectSortedArray< T, A >::CountIf ( UP  p) const
inline

#

Definition at line 915 of file IndirectSortedArray.h.

◆ Delete() [1/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Delete ( iterator  i,
size_type  n = 1 
)
inline

#

Definition at line 746 of file IndirectSortedArray.h.

◆ Delete() [2/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Delete ( iterator  i,
iterator  j 
)
inline

#

Definition at line 753 of file IndirectSortedArray.h.

◆ Delete() [3/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Delete ( const T &  v)
inline

#

Definition at line 770 of file IndirectSortedArray.h.

◆ Delete() [4/5]

template<class T, class A = StandardAllocator>
template<class BP >
void pcl::IndirectSortedArray< T, A >::Delete ( const T &  v,
BP  p 
)
inline

#

Definition at line 782 of file IndirectSortedArray.h.

◆ Delete() [5/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Delete ( )
inline

#

Definition at line 791 of file IndirectSortedArray.h.

◆ Destroy() [1/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Destroy ( iterator  i,
size_type  n = 1 
)
inline

#

Definition at line 798 of file IndirectSortedArray.h.

◆ Destroy() [2/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Destroy ( iterator  i,
iterator  j 
)
inline

#

Definition at line 805 of file IndirectSortedArray.h.

◆ Destroy() [3/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Destroy ( const T &  v)
inline

#

Definition at line 812 of file IndirectSortedArray.h.

◆ Destroy() [4/5]

template<class T, class A = StandardAllocator>
template<class BP >
void pcl::IndirectSortedArray< T, A >::Destroy ( const T &  v,
BP  p 
)
inline

#

Definition at line 823 of file IndirectSortedArray.h.

◆ Destroy() [5/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Destroy ( )
inline

#

Definition at line 831 of file IndirectSortedArray.h.

◆ End()

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::End ( ) const
inline

#

Definition at line 358 of file IndirectSortedArray.h.

◆ end()

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::end ( ) const
inline

STL-compatible iteration. Equivalent to End() const.

Definition at line 465 of file IndirectSortedArray.h.

◆ EnsureUnique()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::EnsureUnique ( )
inline

Ensures that this indirect array uniquely references its contained data pointers.

If necessary, this member function generates a duplicate of the array of pointers, references it, and then decrements the reference counter of the original pointers array.

Definition at line 230 of file IndirectSortedArray.h.

◆ Fill()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Fill ( const T &  v)
inline

Sets all objects contained by this array equal to v.

Definition at line 860 of file IndirectSortedArray.h.

◆ First()

template<class T, class A = StandardAllocator>
const T* pcl::IndirectSortedArray< T, A >::First ( ) const
inline

#

Definition at line 400 of file IndirectSortedArray.h.

◆ FirstThat()

template<class T, class A = StandardAllocator>
template<class F >
const_iterator pcl::IndirectSortedArray< T, A >::FirstThat ( f) const
inline

#

Definition at line 876 of file IndirectSortedArray.h.

◆ GetAllocator()

template<class T, class A = StandardAllocator>
const allocator& pcl::IndirectSortedArray< T, A >::GetAllocator ( ) const
inline

#

Definition at line 295 of file IndirectSortedArray.h.

◆ Hash()

template<class T, class A = StandardAllocator>
uint64 pcl::IndirectSortedArray< T, A >::Hash ( uint64  seed = 0) const
inline

Returns a non-cryptographic hash value computed for this indirect array. This function is a synonym for Hash64().

Definition at line 1217 of file IndirectSortedArray.h.

References pcl::Hash64().

◆ Hash32()

template<class T, class A = StandardAllocator>
uint32 pcl::IndirectSortedArray< T, A >::Hash32 ( uint32  seed = 0) const
inline

Returns a 32-bit non-cryptographic hash value computed for this indirect array.

This function calls pcl::Hash32() for the internal array of pointers, not for the pointed objects.

The seed parameter can be used to generate repeatable hash values. It can also be set to a random value in compromised environments.

Definition at line 1208 of file IndirectSortedArray.h.

◆ Hash64()

template<class T, class A = StandardAllocator>
uint64 pcl::IndirectSortedArray< T, A >::Hash64 ( uint64  seed = 0) const
inline

Returns a 64-bit non-cryptographic hash value computed for this indirect array.

This function calls pcl::Hash64() for the internal array of pointers, not for the pointed objects.

The seed parameter can be used to generate repeatable hash values. It can also be set to a random value in compromised environments.

Definition at line 1193 of file IndirectSortedArray.h.

◆ Import()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Import ( iterator  i,
iterator  j 
)
inline

#

Definition at line 594 of file IndirectSortedArray.h.

References pcl::Sort().

◆ IsAliasOf()

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::IsAliasOf ( const IndirectSortedArray< T, A > &  x) const
inline

Returns true iff this indirect sorted array is an alias of the indirect sorted array x.

Two objects are aliases if both share the same data. Two indirect containers are aliases if they share a unique set of data pointers.

Definition at line 217 of file IndirectSortedArray.h.

◆ IsEmpty()

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::IsEmpty ( ) const
inline

#

Definition at line 274 of file IndirectSortedArray.h.

◆ IsUnique()

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::IsUnique ( ) const
inline

Returns true iff this indirect sorted array uniquely references its contained array of data pointers.

Definition at line 205 of file IndirectSortedArray.h.

◆ IsValid()

template<class T, class A = StandardAllocator>
bool pcl::IndirectSortedArray< T, A >::IsValid ( ) const
inline

#

Definition at line 267 of file IndirectSortedArray.h.

◆ Last()

template<class T, class A = StandardAllocator>
const T* pcl::IndirectSortedArray< T, A >::Last ( ) const
inline

#

Definition at line 414 of file IndirectSortedArray.h.

◆ LastThat()

template<class T, class A = StandardAllocator>
template<class F >
const_iterator pcl::IndirectSortedArray< T, A >::LastThat ( f) const
inline

#

Definition at line 884 of file IndirectSortedArray.h.

◆ Length()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Length ( ) const
inline

#

Definition at line 246 of file IndirectSortedArray.h.

◆ LowerBound()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::LowerBound ( ) const
inline

#

Definition at line 281 of file IndirectSortedArray.h.

◆ MaxItem() [1/2]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::MaxItem ( ) const
inline

#

Definition at line 937 of file IndirectSortedArray.h.

◆ MaxItem() [2/2]

template<class T, class A = StandardAllocator>
template<class BP >
const_iterator pcl::IndirectSortedArray< T, A >::MaxItem ( BP  p) const
inline

#

Definition at line 945 of file IndirectSortedArray.h.

◆ MinItem() [1/2]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::MinItem ( ) const
inline

#

Definition at line 922 of file IndirectSortedArray.h.

◆ MinItem() [2/2]

template<class T, class A = StandardAllocator>
template<class BP >
const_iterator pcl::IndirectSortedArray< T, A >::MinItem ( BP  p) const
inline

#

Definition at line 930 of file IndirectSortedArray.h.

◆ MutableAt()

template<class T, class A = StandardAllocator>
iterator pcl::IndirectSortedArray< T, A >::MutableAt ( size_type  i)
inline

#

Definition at line 316 of file IndirectSortedArray.h.

◆ MutableBegin()

template<class T, class A = StandardAllocator>
iterator pcl::IndirectSortedArray< T, A >::MutableBegin ( )
inline

#

Definition at line 351 of file IndirectSortedArray.h.

◆ MutableEnd()

template<class T, class A = StandardAllocator>
iterator pcl::IndirectSortedArray< T, A >::MutableEnd ( )
inline

#

Definition at line 365 of file IndirectSortedArray.h.

◆ MutableFirst()

template<class T, class A = StandardAllocator>
T* pcl::IndirectSortedArray< T, A >::MutableFirst ( )
inline

#

Definition at line 407 of file IndirectSortedArray.h.

◆ MutableIterator()

template<class T, class A = StandardAllocator>
iterator pcl::IndirectSortedArray< T, A >::MutableIterator ( const_iterator  i)
inline

#

Definition at line 323 of file IndirectSortedArray.h.

◆ MutableLast()

template<class T, class A = StandardAllocator>
T* pcl::IndirectSortedArray< T, A >::MutableLast ( )
inline

#

Definition at line 421 of file IndirectSortedArray.h.

◆ MutableReverseBegin()

template<class T, class A = StandardAllocator>
reverse_iterator pcl::IndirectSortedArray< T, A >::MutableReverseBegin ( )
inline

#

Definition at line 379 of file IndirectSortedArray.h.

◆ MutableReverseEnd()

template<class T, class A = StandardAllocator>
reverse_iterator pcl::IndirectSortedArray< T, A >::MutableReverseEnd ( )
inline

#

Definition at line 393 of file IndirectSortedArray.h.

◆ operator*()

template<class T, class A = StandardAllocator>
const T* pcl::IndirectSortedArray< T, A >::operator* ( ) const
inline

#

Definition at line 337 of file IndirectSortedArray.h.

◆ operator=() [1/4]

template<class T, class A = StandardAllocator>
IndirectSortedArray& pcl::IndirectSortedArray< T, A >::operator= ( const IndirectSortedArray< T, A > &  x)
inline

Copy assignment operator.

Causes this indirect array to reference the same set of pointers as another array x. Returns a reference to this object.

Definition at line 477 of file IndirectSortedArray.h.

◆ operator=() [2/4]

template<class T, class A = StandardAllocator>
IndirectSortedArray& pcl::IndirectSortedArray< T, A >::operator= ( IndirectSortedArray< T, A > &&  x)
inline

Move assignment operator. Returns a reference to this object.

Definition at line 493 of file IndirectSortedArray.h.

◆ operator=() [3/4]

template<class T, class A = StandardAllocator>
IndirectSortedArray& pcl::IndirectSortedArray< T, A >::operator= ( const array_implementation x)
inline

#

Definition at line 515 of file IndirectSortedArray.h.

◆ operator=() [4/4]

template<class T, class A = StandardAllocator>
IndirectSortedArray& pcl::IndirectSortedArray< T, A >::operator= ( array_implementation &&  x)
inline

#

Definition at line 531 of file IndirectSortedArray.h.

◆ operator[]()

template<class T, class A = StandardAllocator>
const T* pcl::IndirectSortedArray< T, A >::operator[] ( size_type  i) const
inline

#

Definition at line 330 of file IndirectSortedArray.h.

◆ Pack()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Pack ( )
inline

#

Definition at line 838 of file IndirectSortedArray.h.

◆ Release()

template<class T, class A = StandardAllocator>
iterator pcl::IndirectSortedArray< T, A >::Release ( )
inline

#

Definition at line 602 of file IndirectSortedArray.h.

◆ Remove() [1/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Remove ( const_iterator  i,
size_type  n = 1 
)
inline

#

Definition at line 666 of file IndirectSortedArray.h.

◆ Remove() [2/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Remove ( const_iterator  i,
const_iterator  j 
)
inline

#

Definition at line 673 of file IndirectSortedArray.h.

◆ Remove() [3/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Remove ( const T &  v)
inline

#

Definition at line 715 of file IndirectSortedArray.h.

◆ Remove() [4/5]

template<class T, class A = StandardAllocator>
template<class BP >
void pcl::IndirectSortedArray< T, A >::Remove ( const T &  v,
BP  p 
)
inline

#

Definition at line 725 of file IndirectSortedArray.h.

◆ Remove() [5/5]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Remove ( const T *  p)
inline

#

Definition at line 732 of file IndirectSortedArray.h.

◆ Reserve()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Reserve ( size_type  n)
inline

#

Definition at line 845 of file IndirectSortedArray.h.

◆ ReverseBegin()

template<class T, class A = StandardAllocator>
const_reverse_iterator pcl::IndirectSortedArray< T, A >::ReverseBegin ( ) const
inline

#

Definition at line 372 of file IndirectSortedArray.h.

◆ ReverseEnd()

template<class T, class A = StandardAllocator>
const_reverse_iterator pcl::IndirectSortedArray< T, A >::ReverseEnd ( ) const
inline

#

Definition at line 386 of file IndirectSortedArray.h.

◆ Search() [1/3]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::Search ( const T &  v) const
inline

#

Definition at line 952 of file IndirectSortedArray.h.

◆ Search() [2/3]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::Search ( const T *  p) const
inline

#

Definition at line 959 of file IndirectSortedArray.h.

◆ Search() [3/3]

template<class T, class A = StandardAllocator>
template<class BP >
const_iterator pcl::IndirectSortedArray< T, A >::Search ( const T &  v,
BP  p 
) const
inline

#

Definition at line 967 of file IndirectSortedArray.h.

◆ SearchLast() [1/3]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::SearchLast ( const T &  v) const
inline

#

Definition at line 974 of file IndirectSortedArray.h.

◆ SearchLast() [2/3]

template<class T, class A = StandardAllocator>
const_iterator pcl::IndirectSortedArray< T, A >::SearchLast ( const T *  p) const
inline

#

Definition at line 981 of file IndirectSortedArray.h.

◆ SearchLast() [3/3]

template<class T, class A = StandardAllocator>
template<class BP >
const_iterator pcl::IndirectSortedArray< T, A >::SearchLast ( const T &  v,
BP  p 
) const
inline

#

Definition at line 989 of file IndirectSortedArray.h.

◆ SetAllocator()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::SetAllocator ( const allocator a)
inline

#

Definition at line 302 of file IndirectSortedArray.h.

◆ Shrink()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Shrink ( size_type  n = 1)
inline

Removes a contiguous trailing sequence of n existing pointers from this indirect array. This operation is equivalent to:

Truncate( End() - n )

If the specified count n is greater than or equal to the length of this array, this function calls Clear() to yield an empty array.

Only pointers are removed by this function; the pointed objects are not affected in any way.

Definition at line 708 of file IndirectSortedArray.h.

◆ Size()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::Size ( ) const
inline

Returns the total number of bytes required to store the array of data pointers in this indirect array.

Definition at line 239 of file IndirectSortedArray.h.

◆ Sort()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Sort ( )
inline

#

Definition at line 1018 of file IndirectSortedArray.h.

◆ Squeeze()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Squeeze ( )
inline

#

Definition at line 852 of file IndirectSortedArray.h.

◆ ToCommaSeparated()

template<class T, class A = StandardAllocator>
template<class S >
S& pcl::IndirectSortedArray< T, A >::ToCommaSeparated ( S &  s) const
inline

Generates a comma-separated sequence of string tokens. Returns a reference to the target string s.

This function is equivalent to:

ToSeparated( s, ',' );

Definition at line 1150 of file IndirectSortedArray.h.

◆ ToSeparated() [1/2]

template<class T, class A = StandardAllocator>
template<class S , typename SP >
S& pcl::IndirectSortedArray< T, A >::ToSeparated ( S &  s,
SP  separator 
) const
inline

Generates a sequence of string tokens separated with the specified separator string. Returns a reference to the target string s.

For each non-null pointer in this indirect array, this function appends a string representation of the pointed object (known as a token) to the target string s. If the array contains more than one non-null pointer, successive tokens are separated with the specified separator.

The string type S must have a meaningful Append() member function and type conversion semantics to transform an array element to a string. The standard String and IsoString PCL classes provide the required functionality for most scalar types, although it is probably better to use String::ToSeparated() and IsoString::ToSeparated() instead of calling these functions directly.

Definition at line 1108 of file IndirectSortedArray.h.

◆ ToSeparated() [2/2]

template<class T, class A = StandardAllocator>
template<class S , typename SP , class AF >
S& pcl::IndirectSortedArray< T, A >::ToSeparated ( S &  s,
SP  separator,
AF  append 
) const
inline

Generates a sequence of string tokens separated with the specified separator string by calling an append function. Returns a reference to the target string s.

For each non-null pointer p in this indirect array, this function appends a string representation of the pointed object (known as a token) to the target string s by calling the append function:

append( s, S( *p ) );

If the array contains more than one non-null pointer, successive tokens are separated by calling:

append( s, S( separator ) );

The string type S must have type conversion semantics to transform an array element to a string. The standard String and IsoString PCL classes provide the required functionality for most scalar types, although it is probably easier to use String::ToSeparated() and IsoString::ToSeparated() instead of calling these functions directly.

Definition at line 1136 of file IndirectSortedArray.h.

◆ ToSpaceSeparated()

template<class T, class A = StandardAllocator>
template<class S >
S& pcl::IndirectSortedArray< T, A >::ToSpaceSeparated ( S &  s) const
inline

Generates a space-separated sequence of string tokens. Returns a reference to the target string s.

This function is equivalent to:

ToSeparated( s, ' ' );

Definition at line 1164 of file IndirectSortedArray.h.

◆ ToTabSeparated()

template<class T, class A = StandardAllocator>
template<class S >
S& pcl::IndirectSortedArray< T, A >::ToTabSeparated ( S &  s) const
inline

Generates a tabulator-separated sequence of string tokens. Returns a reference to the target string s.

This function is equivalent to:

ToSeparated( s, '\t' );

Definition at line 1178 of file IndirectSortedArray.h.

◆ Transfer() [1/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Transfer ( IndirectSortedArray< T, A > &  x)
inline

#

Definition at line 501 of file IndirectSortedArray.h.

◆ Transfer() [2/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Transfer ( IndirectSortedArray< T, A > &&  x)
inline

#

Definition at line 508 of file IndirectSortedArray.h.

◆ Transfer() [3/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Transfer ( array_implementation x)
inline

#

Definition at line 539 of file IndirectSortedArray.h.

References pcl::Sort().

◆ Transfer() [4/4]

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Transfer ( array_implementation &&  x)
inline

#

Definition at line 547 of file IndirectSortedArray.h.

References pcl::Sort().

◆ Truncate()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::Truncate ( const_iterator  i)
inline

Removes a trailing sequence of contiguous pointers from the specified iterator of this indirect array. This operation is equivalent to:

Remove( i, End() )

If the specified iterator is located at or after the end of this array, this function does nothing. Otherwise the iterator is constrained to stay in the range [Begin(),End()) of existing array elements.

Only pointers are removed by this function; the pointed objects are not affected in any way.

Definition at line 691 of file IndirectSortedArray.h.

◆ UniquifyIterator()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::UniquifyIterator ( iterator i)
inline

Ensures that the specified iterator points to a uniquely referenced pointer. If necessary, this function builds a new, uniquely referenced copy of this indirect array by calling EnsureUnique().

If the iterator i is changed, it is guaranteed to point to the pointer at the same array index it was pointing to before calling this function.

Definition at line 434 of file IndirectSortedArray.h.

◆ UniquifyIterators()

template<class T, class A = StandardAllocator>
void pcl::IndirectSortedArray< T, A >::UniquifyIterators ( iterator i,
iterator j 
)
inline

Ensures that the specified iterators point to uniquely referenced pointers. If necessary, this function builds a new, uniquely referenced copy of this indirect array by calling EnsureUnique().

If the iterators i and j are changed, they are guaranteed to point to the pointers at the same array indices they were pointing to before calling this function.

Definition at line 448 of file IndirectSortedArray.h.

◆ UpperBound()

template<class T, class A = StandardAllocator>
size_type pcl::IndirectSortedArray< T, A >::UpperBound ( ) const
inline

#

Definition at line 288 of file IndirectSortedArray.h.

Friends And Related Function Documentation

◆ Swap

template<class T, class A = StandardAllocator>
void Swap ( IndirectSortedArray< T, A > &  x1,
IndirectSortedArray< T, A > &  x2 
)
friend

Exchanges two indirect sorted arrays x1 and x2.

Definition at line 1026 of file IndirectSortedArray.h.


The documentation for this class was generated from the following file: