58 #include <pcl/Diagnostics.h>
65 #include <pcl/Memory.h>
68 #include <pcl/Rotate.h>
98 template <
class T,
class A = StandardAllocator>
144 m_data->Allocate( n );
145 m_data->Initialize( m_data->begin, m_data->end );
154 m_data->Allocate( n );
155 m_data->Initialize( m_data->begin, m_data->end, v );
167 if ( m_data->begin !=
nullptr )
168 m_data->Build( m_data->begin, i, j );
179 template <
typename T1>
180 Array( std::initializer_list<T1> l )
181 :
Array( l.begin(), l.end() )
191 if ( m_data !=
nullptr )
210 if ( m_data !=
nullptr )
222 return m_data->IsUnique();
232 return m_data == x.m_data;
246 Data* newData =
new Data;
247 newData->Allocate( Length() );
248 newData->Build( newData->begin, m_data->begin, m_data->end );
260 return m_data->Size();
268 return m_data->Length();
277 return m_data->Capacity();
288 return m_data->Available();
306 return m_data !=
nullptr;
314 return m_data->IsEmpty();
340 return m_data->alloc;
357 PCL_PRECONDITION( !IsEmpty() && i < Length() )
359 return m_data->begin + i;
367 PCL_PRECONDITION( !IsEmpty() && i < Length() )
368 return m_data->begin + i;
383 return At( i - m_data->begin );
409 PCL_PRECONDITION( m_data->begin !=
nullptr )
411 return *m_data->begin;
419 PCL_PRECONDITION( m_data->begin !=
nullptr )
420 return *m_data->begin;
429 return m_data->begin;
437 return m_data->begin;
445 return m_data->begin;
481 PCL_PRECONDITION( m_data->end !=
nullptr )
483 return m_data->end - 1;
494 PCL_PRECONDITION( m_data->end !=
nullptr )
495 return m_data->end - 1;
506 PCL_PRECONDITION( m_data->end !=
nullptr )
507 return m_data->end - 1;
519 PCL_PRECONDITION( m_data->begin !=
nullptr )
521 return m_data->begin - 1;
533 PCL_PRECONDITION( m_data->begin !=
nullptr )
534 return m_data->begin - 1;
546 PCL_PRECONDITION( m_data->begin !=
nullptr )
547 return m_data->begin - 1;
560 PCL_PRECONDITION( i >= m_data->begin && i <= m_data->end )
565 i = m_data->begin + d;
580 PCL_PRECONDITION( i >= m_data->begin && i <= m_data->end )
581 PCL_PRECONDITION( j >= m_data->begin && j <= m_data->end )
587 j = (i = m_data->begin + d) + r;
591 #ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
704 Data* newData =
new Data;
709 if ( Capacity() < n )
711 m_data->Deallocate();
712 m_data->Allocate( n );
716 m_data->Destroy( m_data->begin, m_data->end );
717 m_data->end = m_data->begin + n;
720 m_data->Initialize( m_data->begin, m_data->end, v );
740 Data* newData =
new Data;
745 if ( Capacity() < n )
747 m_data->Deallocate();
748 m_data->Allocate( n );
752 m_data->Destroy( m_data->begin, m_data->end );
753 m_data->end = m_data->begin + n;
756 m_data->Build( m_data->begin, i, j );
773 if ( i >= m_data->available || j <= m_data->begin )
781 m_data->end = m_data->available = j;
802 m_data->begin = m_data->end = m_data->available =
nullptr;
818 i =
pcl::Range( i, m_data->begin, m_data->end );
821 UniquifyIterator( i );
822 m_data->Initialize( i = m_data->UninitializedGrow( i, n ), n );
838 return Grow( m_data->end, n );
852 if ( n < m_data->Length() )
853 Truncate( m_data->end - n );
893 return Insert( i, x.
Begin(), x.
End() );
896 return Insert( i, t.m_data->begin, t.m_data->end );
911 i =
pcl::Range( i, m_data->begin, m_data->end );
914 UniquifyIterator( i );
915 m_data->Initialize( i = m_data->UninitializedGrow( i, n ), n, v );
935 i =
pcl::Range( i, m_data->begin, m_data->end );
939 UniquifyIterator( i );
940 m_data->Build( i = m_data->UninitializedGrow( i, n ), p, q );
950 Insert( m_data->end, x );
959 Insert( m_data->end, v, n );
971 Insert( m_data->end, p, q );
980 Insert( m_data->begin, x );
989 Insert( m_data->begin, v, n );
1001 Insert( m_data->begin, p, q );
1054 if ( i < m_data->end )
1059 if ( i > m_data->begin || j < m_data->end )
1061 UniquifyIterators( i, j );
1062 m_data->Destroy( j = pcl::Copy( i, j, m_data->end ), m_data->end );
1082 Remove( i, m_data->end );
1092 for (
iterator i = m_data->begin, j = i; ; ++j )
1094 if ( j == m_data->end )
1096 if ( i != m_data->begin )
1121 for (
iterator i = m_data->begin, j = i; ; ++j )
1123 if ( j == m_data->end )
1125 if ( i != m_data->begin )
1157 m_data->Deallocate();
1160 Data* newData =
new Data;
1182 return Replace( i, j, x.
Begin(), x.
End() );
1203 i =
pcl::Range( i, m_data->begin, m_data->end );
1204 j =
pcl::Range( j, m_data->begin, m_data->end );
1206 if ( i < m_data->end )
1208 UniquifyIterators( i, j );
1212 m_data->Destroy( i, j );
1213 m_data->Initialize( i = m_data->UninitializedGrow( i, n-d ), n, v );
1218 pcl::Fill( i, k, v );
1220 if ( m_data->begin ==
nullptr )
1246 i =
pcl::Range( i, m_data->begin, m_data->end );
1247 j =
pcl::Range( j, m_data->begin, m_data->end );
1249 if ( i < m_data->end )
1251 UniquifyIterators( i, j );
1256 m_data->Destroy( i, j );
1257 m_data->Build( i = m_data->UninitializedGrow( i, n-d ), p, q );
1261 Remove( pcl::Move( i, p, q ), j );
1262 if ( m_data->begin ==
nullptr )
1280 if ( Capacity() < n )
1282 iterator b = m_data->alloc.Allocate( n );
1283 iterator e = m_data->Build( b, m_data->begin, m_data->end );
1284 m_data->Deallocate();
1287 m_data->available = m_data->begin + n;
1292 Data* newData =
new Data;
1293 newData->begin = newData->alloc.Allocate( n =
pcl::Max( Length(), n ) );
1294 newData->end = newData->Build( newData->begin, m_data->begin, m_data->end );
1295 newData->available = newData->begin + n;
1317 if ( Available() > 0 )
1319 iterator b = m_data->alloc.Allocate( Length() );
1320 iterator e = m_data->Build( b, m_data->begin, m_data->end );
1321 m_data->Deallocate();
1323 m_data->end = m_data->available = e;
1328 Data* newData =
new Data;
1331 newData->begin = newData->alloc.Allocate( Length() );
1332 newData->available = newData->end = newData->Build( newData->begin, m_data->begin, m_data->end );
1345 pcl::Fill( m_data->begin, m_data->end, v );
1362 pcl::Fill( m_data->begin, m_data->end, v );
1381 void Apply( F f )
const noexcept( noexcept( f ) )
1412 return pcl::Count( m_data->begin, m_data->end, v );
1420 return pcl::Count( m_data->begin, m_data->end, v, p );
1466 pcl::Reverse( m_data->begin, m_data->end );
1473 if ( Length() > 1 && n != 0 )
1476 if ( (n %= Length()) < 0 )
1478 pcl::Rotate( m_data->begin, m_data->begin+n, m_data->end );
1486 if ( !IsEmpty() && n > 0 )
1489 if ( n >= Length() )
1490 pcl::Fill( m_data->begin, m_data->end, v );
1492 pcl::ShiftLeft( m_data->begin, m_data->begin+n, m_data->end, v );
1500 if ( !IsEmpty() && n > 0 )
1503 if ( n >= Length() )
1504 pcl::Fill( m_data->begin, m_data->end, v );
1506 pcl::ShiftRight( m_data->begin, m_data->end-n, m_data->end, v );
1550 template <
class FI,
class BP>
1561 PCL_ASSERT_DIRECT_CONTAINER( C, T );
1562 return const_cast<iterator>(
pcl::Search( m_data->begin, m_data->end, x.Begin(), x.End() ) );
1567 template <
class C,
class BP>
1570 PCL_ASSERT_DIRECT_CONTAINER( C, T );
1571 return const_cast<iterator>(
pcl::Search( m_data->begin, m_data->end, x.Begin(), x.End(), p ) );
1584 template <
class BI,
class BP>
1595 PCL_ASSERT_DIRECT_CONTAINER( C, T );
1601 template <
class C,
class BP>
1604 PCL_ASSERT_DIRECT_CONTAINER( C, T );
1612 return Search( v ) != m_data->end;
1618 bool Contains(
const T& v, BP p )
const noexcept( noexcept( p ) )
1620 return Search( v, p ) != m_data->end;
1628 return SearchSubset( i, j ) != m_data->end;
1633 template <
class FI,
class BP>
1636 return SearchSubset( i, j, p ) != m_data->end;
1644 return SearchSubset( c ) != m_data->end;
1649 template <
class C,
class BP>
1652 return SearchSubset( c, p ) != m_data->end;
1696 template <
class S,
typename SP>
1697 S& ToSeparated( S& s, SP separator )
const
1700 if ( i < m_data->end )
1702 s.Append( S( *i ) );
1703 if ( ++i < m_data->end )
1706 s.Append( separator );
1707 s.Append( S( *i ) );
1709 while ( ++i < m_data->end );
1736 template <
class S,
typename SP,
class AF>
1737 S& ToSeparated( S& s, SP separator, AF append )
const
1740 if ( i < m_data->end )
1742 append( s, S( *i ) );
1743 if ( ++i < m_data->end )
1749 append( s, S( *i ) );
1751 while ( ++i < m_data->end );
1766 S& ToCommaSeparated( S& s )
const
1768 return ToSeparated( s,
',' );
1780 S& ToSpaceSeparated( S& s )
const
1782 return ToSeparated( s,
' ' );
1794 S& ToTabSeparated( S& s )
const
1796 return ToSeparated( s,
'\t' );
1808 S& ToNewLineSeparated( S& s )
const
1810 return ToSeparated( s,
'\n' );
1823 return pcl::Hash64( m_data->begin, m_data->Size(), seed );
1836 return pcl::Hash32( m_data->begin, m_data->Size(), seed );
1859 iterator begin =
nullptr;
1860 iterator end =
nullptr;
1861 iterator available =
nullptr;
1882 return Length()*
sizeof( T );
1898 return available - begin;
1906 return available - end;
1912 bool IsEmpty() const noexcept
1914 return begin == end;
1926 begin = alloc.Allocate( m );
1928 available = begin + m;
1937 PCL_CHECK( (begin ==
nullptr) ? end ==
nullptr : begin < end )
1938 if ( begin !=
nullptr )
1941 alloc.Deallocate( begin );
1942 begin = end = available =
nullptr;
1949 void Initialize( iterator __restrict__ i, iterator __restrict__ j )
1951 for ( ; i < j; ++i )
1959 void Initialize( iterator __restrict__ i,
size_type n )
1961 for ( ; n > 0; ++i, --n )
1969 void Initialize( iterator __restrict__ i, iterator __restrict__ j,
const T& v )
1971 for ( ; i < j; ++i )
1979 void Initialize( iterator __restrict__ i,
size_type n,
const T& v )
1981 for ( ; n > 0; ++i, --n )
1991 iterator Build( iterator __restrict__ i, FI p, FI q )
1993 for ( ; p != q; ++i, ++p )
2003 iterator UninitializedGrow( iterator __restrict__ i,
size_type n )
2006 if ( Available() >= n )
2010 iterator __restrict__ j1 = end;
2011 iterator __restrict__ j2 = end + n;
2022 else if ( j2 == end )
2037 size_type m = alloc.PagedLength( Length()+n );
2038 iterator b = alloc.Allocate( m );
2039 iterator r = Build( b, begin, i );
2040 iterator e = Build( r+n, i, end );
2055 static void Destroy( iterator i, iterator j )
2065 Data* m_data =
nullptr;
2071 void DetachFromData()
2073 if ( !m_data->Detach() )
2089 template <
class T,
class A>
inline
2092 return x1.Length() == x2.Length() &&
pcl::Equal( x1.Begin(), x2.Begin(), x2.End() );
2100 template <
class T,
class A>
inline
2103 return pcl::Compare( x1.Begin(), x1.End(), x2.Begin(), x2.End() ) < 0;
2117 template <
class T,
class A,
class V>
inline
2118 Array<T,A>&
operator <<( Array<T,A>& x,
const V& v )
2131 template <
class T,
class A,
class V>
inline
2132 Array<T,A>&
operator <<( Array<T,A>&& x,
const V& v )
2143 template <
class T,
class A>
inline
2144 Array<T,A>&
operator <<( Array<T,A>& x1,
const Array<T,A>& x2 )
2155 template <
class T,
class A>
inline
2156 Array<T,A>&
operator <<( Array<T,A>&& x1,
const Array<T,A>& x2 )
Provides memory allocation for PCL containers.
iterator SearchSubset(FI i, FI j, BP p) const noexcept(noexcept(p))
iterator Search(const T &v) const noexcept
iterator ContainsSubset(const C &c, BP p) const noexcept(noexcept(p))
uint64 Hash64(uint64 seed=0) const
void Shrink(size_type n=1)
iterator SearchLast(const T &v) const noexcept
void Import(iterator i, iterator j)
bool IsEmpty() const noexcept
size_type LowerBound() const noexcept
void Apply(F f) const noexcept(noexcept(f))
void Remove(iterator i, iterator j)
friend void Swap(Array &x1, Array &x2) noexcept
void ShiftRight(const T &v, size_type n=1)
iterator Grow(iterator i, size_type n=1)
iterator Expand(size_type n=1)
void Prepend(const T &v, size_type n=1)
const allocator & Allocator() const noexcept
iterator FirstThat(F f) const noexcept(noexcept(f))
void Rotate(distance_type n)
const_iterator ConstEnd() const noexcept
iterator MinItem(BP p) const noexcept(noexcept(p))
void UniquifyIterators(iterator &i, iterator &j)
iterator ContainsSubset(const C &c) const noexcept
uint64 Hash(uint64 seed=0) const noexcept
size_type Length() const noexcept
Array(size_type n, const T &v)
iterator Replace(iterator i, iterator j, FI p, FI q)
void Add(const T &v, size_type n=1)
bool IsValid() const noexcept
void UniquifyIterator(iterator &i)
bool IsAliasOf(const Array &x) const noexcept
iterator SearchSubset(const C &x) const noexcept
const_iterator End() const noexcept
bool IsUnique() const noexcept
void Assign(const T &v, size_type n=1)
void Append(const T &v, size_type n=1)
void Append(const Array &x)
void ShiftLeft(const T &v, size_type n=1)
uint32 Hash32(uint32 seed=0) const noexcept
bool Contains(const T &v) const noexcept
size_type Count(const T &v) const noexcept
const_reverse_iterator ReverseEnd() const noexcept
iterator Replace(iterator i, iterator j, const Array &x)
void SetAllocator(const allocator &a)
void Remove(const T &v, BP p)
iterator ContainsSubset(FI i, FI j, BP p) const noexcept(noexcept(p))
const_reverse_iterator ConstReverseBegin() const noexcept
iterator MaxItem(BP p) const noexcept(noexcept(p))
void Assign(const Array &x)
iterator SearchLastSubset(const C &x, BP p) const noexcept(noexcept(p))
const_iterator Begin() const noexcept
Array(std::initializer_list< T1 > l)
void Prepend(const Array &x)
iterator SearchLastSubset(BI i, BI j) const noexcept
iterator SearchLastSubset(const C &x) const noexcept
bool Contains(const T &v, BP p) const noexcept(noexcept(p))
size_type UpperBound() const noexcept
iterator Replace(iterator i, iterator j, const T &v, size_type n=1)
size_type Count(const T &v, BP p) const noexcept(noexcept(p))
const_iterator begin() const noexcept
iterator MinItem() const noexcept
const_reverse_iterator ConstReverseEnd() const noexcept
iterator Insert(iterator i, FI p, FI q)
reverse_iterator ReverseEnd()
iterator SearchSubset(const C &x, BP p) const noexcept(noexcept(p))
iterator Insert(iterator i, const Array &x)
iterator Insert(iterator i, const T &v, size_type n=1)
const_iterator At(size_type i) const noexcept
iterator ContainsSubset(FI i, FI j) const noexcept
iterator SearchSubset(FI i, FI j) const noexcept
reverse_iterator ReverseBegin()
size_type Capacity() const noexcept
const_iterator end() const noexcept
iterator SearchLast(const T &v, BP p) const noexcept(noexcept(p))
void Truncate(iterator i)
void SecureFill(const T &v)
size_type Size() const noexcept
iterator Search(const T &v, BP p) const noexcept(noexcept(p))
iterator LastThat(F f) const noexcept(noexcept(f))
void Reserve(size_type n)
const_iterator ConstBegin() const noexcept
size_type CountIf(UP p) const noexcept(noexcept(p))
iterator MaxItem() const noexcept
void Remove(iterator i, size_type n=1)
const_reverse_iterator ReverseBegin() const noexcept
iterator SearchLastSubset(BI i, BI j, BP p) const noexcept(noexcept(p))
size_type Available() const noexcept
iterator MutableIterator(const_iterator i)
Root base class of all PCL containers of objects.
Thread-safe reference counter for copy-on-write data structures.
Reverse random access iterator.
Array< T, A > & operator<<(Array< T, A > &x, const V &v)
bool operator==(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
bool operator<(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
Complex< T1 > operator*(const Complex< T1 > &c1, const Complex< T2 > &c2) noexcept
uint64 Hash64(const void *data, size_type size, uint64 seed=0) noexcept
uint32 Hash32(const void *data, size_type size, uint32 seed=0) noexcept
void Rotate(T &x, T &y, T1 sa, T1 ca, T2 xc, T2 yc) noexcept
void Construct(T *p, A &a)
void Swap(GenericPoint< T > &p1, GenericPoint< T > &p2) noexcept
unsigned long long uint64
FI LinearSearch(FI i, FI j, const T &v) noexcept
BI1 SearchLast(BI1 i1, BI1 j1, FI2 i2, FI2 j2) noexcept
BI LinearSearchLast(BI i, BI j, const T &v) noexcept
FI1 Search(FI1 i1, FI1 j1, FI2 i2, FI2 j2) noexcept
void QuickSort(RI i, RI j)
size_type CountIf(FI i, FI j, UP p) noexcept(noexcept(p))
constexpr const T & Min(const T &a, const T &b) noexcept
BI LastThat(BI i, BI j, UP p) noexcept(noexcept(p))
size_type Count(FI i, FI j, const T &v) noexcept
FI MinItem(FI i, FI j) noexcept
bool Equal(FI1 i1, FI2 i2, FI2 j2) noexcept
int Compare(FI1 i1, FI1 j1, FI2 i2, FI2 j2) noexcept
constexpr const T & Range(const T &x, const T &a, const T &b) noexcept
constexpr const T & Max(const T &a, const T &b) noexcept
FI MaxItem(FI i, FI j) noexcept
void Apply(FI i, FI j, F f) noexcept(noexcept(f))
FI FirstThat(FI i, FI j, UP p) noexcept(noexcept(p))
distance_type Distance(FI i, FI j)