PCL
ReferenceSortedArray.h
Go to the documentation of this file.
1 // ____ ______ __
2 // / __ \ / ____// /
3 // / /_/ // / / /
4 // / ____// /___ / /___ PixInsight Class Library
5 // /_/ \____//_____/ PCL 2.1.19
6 // ----------------------------------------------------------------------------
7 // pcl/ReferenceSortedArray.h - Released 2019-11-07T10:59:34Z
8 // ----------------------------------------------------------------------------
9 // This file is part of the PixInsight Class Library (PCL).
10 // PCL is a multiplatform C++ framework for development of PixInsight modules.
11 //
12 // Copyright (c) 2003-2019 Pleiades Astrophoto S.L. All Rights Reserved.
13 //
14 // Redistribution and use in both source and binary forms, with or without
15 // modification, is permitted provided that the following conditions are met:
16 //
17 // 1. All redistributions of source code must retain the above copyright
18 // notice, this list of conditions and the following disclaimer.
19 //
20 // 2. All redistributions in binary form must reproduce the above copyright
21 // notice, this list of conditions and the following disclaimer in the
22 // documentation and/or other materials provided with the distribution.
23 //
24 // 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
25 // of their contributors, may be used to endorse or promote products derived
26 // from this software without specific prior written permission. For written
27 // permission, please contact info@pixinsight.com.
28 //
29 // 4. All products derived from this software, in any form whatsoever, must
30 // reproduce the following acknowledgment in the end-user documentation
31 // and/or other materials provided with the product:
32 //
33 // "This product is based on software from the PixInsight project, developed
34 // by Pleiades Astrophoto and its contributors (http://pixinsight.com/)."
35 //
36 // Alternatively, if that is where third-party acknowledgments normally
37 // appear, this acknowledgment must be reproduced in the product itself.
38 //
39 // THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
40 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
41 // TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
43 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
44 // EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
45 // INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
46 // DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
47 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
49 // POSSIBILITY OF SUCH DAMAGE.
50 // ----------------------------------------------------------------------------
51 
52 #ifndef __PCL_ReferenceSortedArray_h
53 #define __PCL_ReferenceSortedArray_h
54 
56 
57 #include <pcl/Diagnostics.h>
58 
59 #include <pcl/Allocator.h>
60 #include <pcl/Container.h>
62 #include <pcl/Iterator.h>
63 #include <pcl/ReferenceArray.h>
64 #include <pcl/SortedArray.h>
65 #include <pcl/StdAlloc.h>
66 
67 namespace pcl
68 {
69 
70 // ----------------------------------------------------------------------------
71 
99 template <typename T, class A = StandardAllocator>
100 class PCL_CLASS ReferenceSortedArray : public DirectContainer<T>
101 {
102 public:
103 
107 
112 
115  typedef typename array_implementation::allocator
117 
120  typedef typename array_implementation::iterator
122 
125  typedef typename array_implementation::const_iterator
127 
132 
137 
142 
147 
148  // -------------------------------------------------------------------------
149 
153  ReferenceSortedArray() : m_array()
154  {
155  }
156 
163  ReferenceSortedArray( size_type n, const T* p ) : m_array()
164  {
165  PCL_PRECONDITION( p != nullptr )
166  if ( p != nullptr )
167  m_array = array_implementation( n, p );
168  }
169 
179  template <class FI>
180  ReferenceSortedArray( FI i, FI j ) : m_array( i, j )
181  {
182  Sort();
183  }
184 
188  ReferenceSortedArray( const ReferenceSortedArray& x ) : m_array( x.m_array )
189  {
190  }
191 
195  ReferenceSortedArray( ReferenceSortedArray&& x ) : m_array( std::move( x.m_array ) )
196  {
197  }
198 
207  {
208  }
209 
214  bool IsUnique() const
215  {
216  return m_array.IsUnique();
217  }
218 
225  bool IsAliasOf( const ReferenceSortedArray& x ) const
226  {
227  return m_array.IsAliasOf( x.m_array );
228  }
229 
239  {
240  m_array.EnsureUnique();
241  }
242 
247  size_type Size() const
248  {
249  return m_array.Size();
250  }
251 
256  {
257  return m_array.Length();
258  }
259 
266  {
267  return m_array.Capacity();
268  }
269 
278  {
279  return m_array.Available();
280  }
281 
297  bool IsValid() const
298  {
299  return m_array.IsValid();
300  }
301 
305  bool IsEmpty() const
306  {
307  return m_array.IsEmpty();
308  }
309 
315  {
316  return m_array.LowerBound();
317  }
318 
324  {
325  return m_array.UpperBound();
326  }
327 
331  const allocator& GetAllocator() const
332  {
333  return m_array.GetAllocator();
334  }
335 
339  void SetAllocator( const allocator& a )
340  {
341  m_array.SetAllocator( a );
342  }
343 
349  {
350  return m_array.At( i );
351  }
352 
358  {
359  return m_array.At( i );
360  }
361 
373  {
374  return m_array.MutableIterator( i );
375  }
376 
381  const T& operator []( size_type i ) const
382  {
383  return m_array[i];
384  }
385 
390  const T& operator *() const
391  {
392  return *m_array;
393  }
394 
399  {
400  return m_array.ConstBegin();
401  }
402 
407  {
408  return m_array.Begin();
409  }
410 
415  {
416  return m_array.ConstEnd();
417  }
418 
423  {
424  return m_array.End();
425  }
426 
434  {
435  return m_array.ConstReverseBegin();
436  }
437 
445  {
446  return m_array.ReverseBegin();
447  }
448 
457  {
458  return m_array.ConstReverseEnd();
459  }
460 
469  {
470  return m_array.ReverseEnd();
471  }
472 
477  const T& First() const
478  {
479  return m_array.First();
480  }
481 
486  T& MutableFirst()
487  {
488  return m_array.First();
489  }
490 
495  const T& Last() const
496  {
497  return m_array.Last();
498  }
499 
504  T& MutableLast()
505  {
506  return m_array.Last();
507  }
508 
519  {
520  m_array.UniquifyIterator( i );
521  }
522 
534  {
535  m_array.UniquifyIterators( i, j );
536  }
537 
538 #ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
539 
543  {
544  return Begin();
545  }
546 
551  {
552  return End();
553  }
554 #endif // !__PCL_NO_STL_COMPATIBLE_ITERATORS
555 
564  {
565  Assign( x );
566  return *this;
567  }
568 
578  void Assign( const ReferenceSortedArray& x )
579  {
580  m_array.Assign( x.m_array );
581  }
582 
587  {
588  Transfer( x );
589  return *this;
590  }
591 
602  {
603  m_array.Transfer( x.m_array );
604  }
605 
616  {
617  m_array.Transfer( std::move( x.m_array ) );
618  }
619 
627  ReferenceSortedArray& operator =( const array_implementation& x )
628  {
629  Assign( x );
630  return *this;
631  }
632 
640  void Assign( const array_implementation& x )
641  {
642  m_array.Assign( x );
643  Sort();
644  }
645 
652  ReferenceSortedArray& operator =( array_implementation&& x )
653  {
654  Transfer( x );
655  return *this;
656  }
657 
667  void Transfer( array_implementation& x )
668  {
669  m_array.Transfer( x );
670  Sort();
671  }
672 
682  void Transfer( array_implementation&& x )
683  {
684  m_array.Transfer( std::move( x ) );
685  Sort();
686  }
687 
694  void Assign( const T* p, size_type n = 1 )
695  {
696  m_array.Assign( p, n );
697  }
698 
710  template <class FI>
711  void Assign( FI i, FI j )
712  {
713  m_array.Assign( i, j );
714  Sort();
715  }
716 
728  template <class C>
729  void CloneAssign( const C& x )
730  {
731  m_array.CloneAssign( x );
732  Sort();
733  }
734 
738  {
739  m_array.CloneAssign( x.m_array );
740  }
741 
745  {
746  m_array.CloneAssign( x );
747  }
748 
752  {
753  m_array.CloneAssign( x );
754  }
755 
763  void Import( iterator i, iterator j )
764  {
765  m_array.Import( i, j );
766  Sort();
767  }
768 
781  {
782  return m_array.Release();
783  }
784 
787  void Add( const ReferenceSortedArray& x )
788  {
789  const_iterator p = x.Begin(), q = x.End();
790  for ( iterator i = Begin(); i < End() && p < q; ++i )
791  if ( *p < *i )
792  i = m_array.Insert( i, (T*)p++ );
793  if ( p < q )
794  m_array.Append( p, q );
795  }
796 
799  void Add( const array_implementation& x )
800  {
801  Add( x.Begin(), x.End() );
802  }
803 
806  const_iterator Add( const T* p, size_type n = 1 )
807  {
808  if ( p != nullptr )
809  return m_array.Insert( pcl::InsertionPoint( Begin(), End(), *p ), p, n );
810  return const_iterator( nullptr );
811  }
812 
815  template <class FI>
816  void Add( FI i, FI j )
817  {
818  if ( i != j )
819  {
820  EnsureUnique();
821  for ( const_iterator l = Begin(), r = End(); ; )
822  {
823  FI h = i;
824  const_iterator m = m_array.Insert( pcl::InsertionPoint( l, r, **i ), *i );
825 
826  if ( ++i == j )
827  break;
828 
829  if ( **i < **h )
830  {
831  l = m_array.Begin();
832  r = m;
833  }
834  else
835  {
836  l = m + 1;
837  r = m_array.End();
838  }
839  }
840  }
841  }
842 
850  void Remove( const_iterator i, size_type n = 1 )
851  {
852  m_array.Remove( i, n );
853  }
854 
863  {
864  m_array.Remove( i, j );
865  }
866 
881  {
882  m_array.Truncate( i );
883  }
884 
897  void Shrink( size_type n = 1 )
898  {
899  m_array.Shrink( n );
900  }
901 
909  void Remove( const T& v )
910  {
911  m_array.Remove( v );
912  }
913 
921  template <class BP>
922  void Remove( const T& v, BP p )
923  {
924  m_array.Remove( v, p );
925  }
926 
933  void RemovePointer( const T* p )
934  {
935  m_array.RemovePointer( p );
936  }
937 
952  void Clear()
953  {
954  m_array.Clear();
955  }
956 
968  void Destroy( iterator i, size_type n = 1 )
969  {
970  m_array.Destroy( i, n );
971  }
972 
991  void Destroy( iterator i, iterator j )
992  {
993  m_array.Destroy( i, j );
994  }
995 
1007  void Destroy( const T& v )
1008  {
1009  m_array.Destroy( v );
1010  }
1011 
1023  template <class BP>
1024  void Destroy( const T& v, BP p )
1025  {
1026  m_array.Destroy( v, p );
1027  }
1028 
1036  void Destroy()
1037  {
1038  m_array.Destroy();
1039  }
1040 
1048  void Reserve( size_type n )
1049  {
1050  m_array.Reserve( n );
1051  }
1052 
1065  void Squeeze()
1066  {
1067  m_array.Squeeze();
1068  }
1069 
1073  void Fill( const T& v )
1074  {
1075  m_array.Fill( v );
1076  }
1077 
1082  template <class F>
1083  void Apply( F f ) const
1084  {
1085  pcl::Apply( Begin(), End(), f );
1086  }
1087 
1093  template <class F>
1095  {
1096  return pcl::FirstThat( Begin(), End(), f );
1097  }
1098 
1104  template <class F>
1106  {
1107  return pcl::LastThat( Begin(), End(), f );
1108  }
1109 
1113  size_type Count( const T& v ) const
1114  {
1115  const_iterator i = pcl::BinarySearch( Begin(), End(), v );
1116  return (i != End()) ? pcl::InsertionPoint( i+1, End(), v ) - i : 0;
1117  }
1118 
1126  size_type Count( const T* p ) const
1127  {
1128  return m_array.Count( p );
1129  }
1130 
1135  template <class BP>
1136  size_type Count( const T& v, BP p ) const
1137  {
1138  return m_array.Count( v, p );
1139  }
1140 
1145  template <class UP>
1146  size_type CountIf( UP p ) const
1147  {
1148  return m_array.CountIf( p );
1149  }
1150 
1154  {
1155  return Begin();
1156  }
1157 
1160  template <class BP>
1161  const_iterator MinItem( BP p ) const
1162  {
1163  return pcl::MinItem( Begin(), End(), p );
1164  }
1165 
1169  {
1170  return IsEmpty() ? End() : End()-1;
1171  }
1172 
1175  template <class BP>
1176  const_iterator MaxItem( BP p ) const
1177  {
1178  return pcl::MaxItem( Begin(), End(), p );
1179  }
1180 
1183  const_iterator Search( const T& v ) const
1184  {
1185  return pcl::BinarySearch( Begin(), End(), v );
1186  }
1187 
1190  const_iterator Search( const T* p ) const
1191  {
1192  return m_array.Search( p );
1193  }
1194 
1197  template <class BP>
1198  const_iterator Search( const T& v, BP p ) const
1199  {
1200  return pcl::LinearSearch( Begin(), End(), v, p );
1201  }
1202 
1205  const_iterator SearchLast( const T& v ) const
1206  {
1207  return pcl::BinarySearchLast( Begin(), End(), v );
1208  }
1209 
1212  const_iterator SearchLast( const T* p ) const
1213  {
1214  return m_array.SearchLast( p );
1215  }
1216 
1219  template <class BP>
1220  const_iterator SearchLast( const T& v, BP p ) const
1221  {
1222  return pcl::LinearSearchLast( Begin(), End(), v, p );
1223  }
1224 
1227  bool Contains( const T& v ) const
1228  {
1229  return Search( v ) != End();
1230  }
1231 
1234  bool Contains( const T* p ) const
1235  {
1236  return m_array.Contains( p );
1237  }
1238 
1241  template <class BP>
1242  bool Contains( const T& v, BP p ) const
1243  {
1244  return Search( v, p ) != End();
1245  }
1246 
1249  void Sort()
1250  {
1251  m_array.Sort();
1252  }
1253 
1258  {
1259  pcl::Swap( x1.m_array, x2.m_array );
1260  }
1261 
1267  friend bool operator ==( const ReferenceSortedArray& x1, const ReferenceSortedArray& x2 )
1268  {
1269  return x1.m_array == x2.m_array;
1270  }
1271 
1277  friend bool operator ==( const ReferenceSortedArray& x1, const array_implementation& x2 )
1278  {
1279  return x1.m_array == x2;
1280  }
1281 
1287  friend bool operator ==( const array_implementation& x1, const ReferenceSortedArray& x2 )
1288  {
1289  return x1 == x2.m_array;
1290  }
1291 
1297  friend bool operator <( const ReferenceSortedArray& x1, const ReferenceSortedArray& x2 )
1298  {
1299  return x1.m_array < x2.m_array;
1300  }
1301 
1307  friend bool operator <( const ReferenceSortedArray& x1, const array_implementation& x2 )
1308  {
1309  return x1.m_array < x2;
1310  }
1311 
1317  friend bool operator <( const array_implementation& x1, const ReferenceSortedArray& x2 )
1318  {
1319  return x1 < x2.m_array;
1320  }
1321 
1338  template <class S, typename SP>
1339  S& ToSeparated( S& s, SP separator ) const
1340  {
1341  return m_array.ToSeparated( s, separator );
1342  }
1343 
1366  template <class S, typename SP, class AF>
1367  S& ToSeparated( S& s, SP separator, AF append ) const
1368  {
1369  return m_array.ToSeparated( s, separator, append );
1370  }
1371 
1380  template <class S>
1381  S& ToCommaSeparated( S& s ) const
1382  {
1383  return m_array.ToCommaSeparated( s );
1384  }
1385 
1394  template <class S>
1395  S& ToSpaceSeparated( S& s ) const
1396  {
1397  return m_array.ToSpaceSeparated( s );
1398  }
1399 
1408  template <class S>
1409  S& ToTabSeparated( S& s ) const
1410  {
1411  return m_array.ToTabSeparated( s );
1412  }
1413 
1424  uint64 Hash64( uint64 seed = 0 ) const
1425  {
1426  return m_array.Hash64( seed );
1427  }
1428 
1439  uint32 Hash32( uint32 seed = 0 ) const
1440  {
1441  return m_array.Hash32( seed );
1442  }
1443 
1448  uint64 Hash( uint64 seed = 0 ) const
1449  {
1450  return Hash64( seed );
1451  }
1452 
1453 private:
1454 
1455  array_implementation m_array;
1456 };
1457 
1458 // ----------------------------------------------------------------------------
1459 
1467 template <class T, class A, class V> inline
1468 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>& x, const V* p )
1469 {
1470  x.Add( static_cast<const T*>( p ) );
1471  return x;
1472 }
1473 
1481 template <class T, class A, class V> inline
1482 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>&& x, const V* p )
1483 {
1484  x.Add( static_cast<const T*>( p ) );
1485  return x;
1486 }
1487 
1493 template <class T, class A> inline
1494 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>& x1, const ReferenceSortedArray<T,A>& x2 )
1495 {
1496  x1.Add( x2 );
1497  return x1;
1498 }
1499 
1505 template <class T, class A> inline
1506 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>&& x1, const ReferenceSortedArray<T,A>& x2 )
1507 {
1508  x1.Add( x2 );
1509  return x1;
1510 }
1511 
1517 template <class T, class A> inline
1518 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>& x1, const ReferenceArray<T,A>& x2 )
1519 {
1520  x1.Add( x2 );
1521  return x1;
1522 }
1523 
1529 template <class T, class A> inline
1530 ReferenceSortedArray<T,A>& operator <<( ReferenceSortedArray<T,A>&& x1, const ReferenceArray<T,A>& x2 )
1531 {
1532  x1.Add( x2 );
1533  return x1;
1534 }
1535 
1536 // ----------------------------------------------------------------------------
1537 
1538 } // pcl
1539 
1540 #endif // __PCL_ReferenceSortedArray_h
1541 
1542 // ----------------------------------------------------------------------------
1543 // EOF pcl/ReferenceSortedArray.h - Released 2019-11-07T10:59:34Z
void Import(iterator i, iterator j)
bool Contains(const T &v, BP p) const
uint64 Hash64(const void *data, size_type size, uint64 seed=0)
Definition: Math.h:3551
const_iterator Search(const T &v, BP p) const
void Transfer(ReferenceSortedArray &x)
Complex< T1 > operator*(const Complex< T1 > &c1, const Complex< T2 > &c2)
Definition: Complex.h:539
Dynamic sorted array of pointers to objects providing direct iteration and element access by referenc...
void Assign(const ReferenceSortedArray &x)
size_type CountIf(UP p) const
BI LinearSearchLast(BI i, BI j, const T &v)
Definition: Search.h:129
array_implementation::const_iterator const_iterator
void Swap(GenericPoint< T > &p1, GenericPoint< T > &p2)
Definition: Point.h:1402
ReferenceArray< T, A > array_implementation
Dynamic array of pointers to objects providing direct iteration and element access by reference...
void Transfer(array_implementation &x)
void UniquifyIterators(iterator &i, iterator &j)
bool Contains(const T &v) const
const_reverse_iterator ReverseEnd() const
PCL root namespace.
Definition: AbstractImage.h:76
BI LastThat(BI i, BI j, UP p)
Definition: Utility.h:350
Mutable ReferenceArray iterator.
friend void Swap(ReferenceSortedArray &x1, ReferenceSortedArray &x2)
const_iterator LastThat(F f) const
const_iterator MaxItem() const
FI BinarySearchLast(FI i, FI j, const T &v)
Definition: Search.h:238
const_iterator MinItem() const
FI LinearSearch(FI i, FI j, const T &v)
Definition: Search.h:91
size_type Count(const T &v, BP p) const
void Destroy(iterator i, size_type n=1)
reverse_iterator MutableReverseBegin()
void CloneAssign(ReferenceSortedArray &x)
FI MaxItem(FI i, FI j)
Definition: Utility.h:479
void CloneAssign(SortedArray< T, A > &x)
iterator MutableAt(size_type i)
void Sort(BI i, BI j)
Definition: Sort.h:534
uint64 Hash(uint64 seed=0) const
const_iterator begin() const
const_iterator At(size_type i) const
Mutable ReferenceArray reverse iterator.
const_iterator end() const
const_iterator Search(const T &v) const
size_t size_type
Definition: Defs.h:543
const_iterator SearchLast(const T *p) const
Provides memory allocation for PCL containers.
Definition: Allocator.h:131
ReferenceSortedArray(ReferenceSortedArray &&x)
FI InsertionPoint(FI i, FI j, const T &v)
Definition: Search.h:326
void Apply(FI i, FI j, F f)
Definition: Utility.h:249
FI BinarySearch(FI i, FI j, const T &v)
Definition: Search.h:170
void Destroy(iterator i, iterator j)
unsigned long long uint64
Definition: Defs.h:616
uint64 Hash64(uint64 seed=0) const
const_iterator Begin() const
ReferenceSortedArray(const ReferenceSortedArray &x)
const_iterator SearchLast(const T &v) const
const_reverse_iterator ReverseBegin() const
bool Contains(const T *p) const
void Remove(const_iterator i, size_type n=1)
reverse_iterator MutableReverseEnd()
array_implementation::block_allocator block_allocator
Immutable ReferenceArray reverse iterator.
array_implementation::allocator allocator
size_type Count(const T *p) const
void Transfer(ReferenceSortedArray &&x)
bool operator<(const Array< T, A > &x1, const Array< T, A > &x2)
Definition: Array.h:2086
array_implementation::const_indirect_iterator const_indirect_iterator
array_implementation::indirect_iterator indirect_iterator
array_implementation::block_allocator block_allocator
ReferenceSortedArray(size_type n, const T *p)
void Assign(const array_implementation &x)
size_type Count(const T &v) const
const allocator & GetAllocator() const
const_iterator Add(const T *p, size_type n=1)
array_implementation::const_reverse_iterator const_reverse_iterator
void Transfer(array_implementation &&x)
const_iterator MaxItem(BP p) const
void Remove(const_iterator i, const_iterator j)
void Truncate(const_iterator i)
Root base class of all PCL containers of objects.
Definition: Container.h:77
void Add(const array_implementation &x)
array_implementation::iterator indirect_iterator
uint32 Hash32(uint32 seed=0) const
array_implementation::const_iterator const_indirect_iterator
array_implementation::iterator iterator
void CloneAssign(IndirectSortedArray< T, A > &x)
FI MinItem(FI i, FI j)
Definition: Utility.h:441
FI1 Search(FI1 i1, FI1 j1, FI2 i2, FI2 j2)
Definition: Search.h:397
bool operator==(const Array< T, A > &x1, const Array< T, A > &x2)
Definition: Array.h:2075
void Destroy(const T &v, BP p)
const_iterator Search(const T *p) const
Generic dynamic sorted array of pointers to objects.
void Assign(const T *p, size_type n=1)
const_iterator FirstThat(F f) const
void Remove(const T &v, BP p)
FI FirstThat(FI i, FI j, UP p)
Definition: Utility.h:316
void SetAllocator(const allocator &a)
const_iterator End() const
unsigned int uint32
Definition: Defs.h:600
const_iterator SearchLast(const T &v, BP p) const
const_iterator MinItem(BP p) const
void UniquifyIterator(iterator &i)
Immutable ReferenceArray iterator.
array_implementation::reverse_iterator reverse_iterator
Generic dynamic sorted array.
Definition: SortedArray.h:82
void Add(const ReferenceSortedArray &x)
iterator MutableIterator(const_iterator i)
bool IsAliasOf(const ReferenceSortedArray &x) const