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
623 #endif // !__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
2131 template <
class T,
class A,
class V>
inline
2143 template <
class T,
class A>
inline
2155 template <
class T,
class A>
inline
2166 #endif // __PCL_Array_h