PCL
SortedArray.h
Go to the documentation of this file.
1 // ____ ______ __
2 // / __ \ / ____// /
3 // / /_/ // / / /
4 // / ____// /___ / /___ PixInsight Class Library
5 // /_/ \____//_____/ PCL 2.7.0
6 // ----------------------------------------------------------------------------
7 // pcl/SortedArray.h - Released 2024-06-18T15:48:54Z
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-2024 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 (https://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_SortedArray_h
53 #define __PCL_SortedArray_h
54 
56 
57 #include <pcl/Defs.h>
58 #include <pcl/Diagnostics.h>
59 
60 #include <pcl/Array.h>
61 
62 namespace pcl
63 {
64 
65 // ----------------------------------------------------------------------------
66 
81 template <class T, class A = StandardAllocator>
82 class PCL_CLASS SortedArray : public DirectSortedContainer<T>
83 {
84 public:
85 
89 
93 
97 
101 
105 
109 
113 
114  // -------------------------------------------------------------------------
115 
119  SortedArray() = default;
120 
124  explicit
126  : m_array( n )
127  {
128  }
129 
133  SortedArray( size_type n, const T& v )
134  : m_array( n, v )
135  {
136  }
137 
142  template <class FI>
143  SortedArray( FI i, FI j )
144  : m_array( i, j )
145  {
146  Sort();
147  }
148 
157  template <typename T1>
158  SortedArray( std::initializer_list<T1> l )
159  : SortedArray( l.begin(), l.end() )
160  {
161  }
162 
166  SortedArray( const SortedArray& ) = default;
167 
171  SortedArray( SortedArray&& ) = default;
172 
178  {
179  }
180 
184  bool IsUnique() const
185  {
186  return m_array.IsUnique();
187  }
188 
194  bool IsAliasOf( const SortedArray& x ) const
195  {
196  return m_array.IsAliasOf( x.m_array );
197  }
198 
207  {
208  m_array.EnsureUnique();
209  }
210 
215  size_type Size() const
216  {
217  return m_array.Size();
218  }
219 
224  {
225  return m_array.Length();
226  }
227 
231  {
232  return m_array.Capacity();
233  }
234 
238  {
239  return m_array.Available();
240  }
241 
244  bool IsValid() const
245  {
246  return m_array.IsValid();
247  }
248 
251  bool IsEmpty() const
252  {
253  return m_array.IsEmpty();
254  }
255 
259  {
260  return m_array.LowerBound();
261  }
262 
266  {
267  return m_array.UpperBound();
268  }
269 
272  const allocator& Allocator() const
273  {
274  return m_array.Allocator();
275  }
276 
279  void SetAllocator( const allocator& a )
280  {
281  m_array.SetAllocator( a );
282  }
283 
287  {
288  return m_array.At( i );
289  }
290 
294  {
295  return m_array.At( i );
296  }
297 
301  {
302  return m_array.MutableIterator( i );
303  }
304 
307  const T& operator []( size_type i ) const
308  {
309  return m_array[i];
310  }
311 
314  const T& operator *() const
315  {
316  return *Begin();
317  }
318 
322  {
323  return m_array.ConstBegin();
324  }
325 
329  {
330  return m_array.Begin();
331  }
332 
336  {
337  return m_array.ConstEnd();
338  }
339 
343  {
344  return m_array.End();
345  }
346 
350  {
351  return m_array.ConstReverseBegin();
352  }
353 
357  {
358  return m_array.ReverseBegin();
359  }
360 
364  {
365  return m_array.ConstReverseEnd();
366  }
367 
371  {
372  return m_array.ReverseEnd();
373  }
374 
384  {
385  return m_array.UniquifyIterator( i );
386  }
387 
398  {
399  return m_array.UniquifyIterators( i, j );
400  }
401 
402 #ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
407  {
408  return Begin();
409  }
410 
415  {
416  return End();
417  }
418 #endif // !__PCL_NO_STL_COMPATIBLE_ITERATORS
419 
426  SortedArray& operator =( const SortedArray& x )
427  {
428  Assign( x );
429  return *this;
430  }
431 
434  void Assign( const SortedArray& x )
435  {
436  m_array.Assign( x.m_array );
437  }
438 
442  SortedArray& operator =( SortedArray&& x )
443  {
444  Transfer( x );
445  return *this;
446  }
447 
451  {
452  m_array.Transfer( x.m_array );
453  }
454 
457  void Transfer( SortedArray&& x )
458  {
459  m_array.Transfer( x.m_array );
460  }
461 
464  SortedArray& operator =( const array_implementation& x )
465  {
466  Assign( x );
467  return *this;
468  }
469 
472  void Assign( const array_implementation& x )
473  {
474  m_array.Assign( x );
475  Sort();
476  }
477 
481  {
482  Transfer( x );
483  return *this;
484  }
485 
489  {
490  m_array.Transfer( x );
491  Sort();
492  }
493 
497  {
498  m_array.Transfer( x );
499  Sort();
500  }
501 
504  void Assign( const T& v, size_type n = 1 )
505  {
506  m_array.Assign( v, n );
507  }
508 
511  template <class FI>
512  void Assign( FI i, FI j )
513  {
514  m_array.Assign( i, j );
515  Sort();
516  }
517 
520  void Import( iterator i, iterator j )
521  {
522  m_array.Import( i, j );
523  Sort();
524  }
525 
529  {
530  return m_array.Release();
531  }
532 
535  void Add( const SortedArray& x )
536  {
537  const_iterator p = x.Begin(), q = x.End();
538  for ( iterator i = m_array.Begin(); i < m_array.End() && p < q; ++i )
539  if ( *p < *i )
540  i = m_array.Insert( i, *p++ );
541  if ( p < q )
542  m_array.Append( p, q );
543  }
544 
547  void Add( const Array<T,A>& x )
548  {
549  Add( x.Begin(), x.End() );
550  }
551 
554  const_iterator Add( const T& v, size_type n = 1 )
555  {
556  return m_array.Insert( pcl::InsertionPoint( m_array.Begin(), m_array.End(), v ), v, n );
557  }
558 
561  template <class FI>
562  void Add( FI i, FI j )
563  {
564  if ( i != j )
565  {
566  m_array.EnsureUnique();
567  for ( iterator l = m_array.Begin(), r = m_array.End(); ; )
568  {
569  FI h = i;
570  iterator m = m_array.Insert( pcl::InsertionPoint( l, r, *i ), *i );
571 
572  if ( ++i == j )
573  break;
574 
575  if ( *i < *h )
576  {
577  l = m_array.Begin();
578  r = m;
579  }
580  else
581  {
582  l = m + 1;
583  r = m_array.End();
584  }
585  }
586  }
587  }
588 
591  void Remove( const_iterator i, size_type n = 1 )
592  {
593  m_array.Remove( const_cast<iterator>( i ), n );
594  }
595 
599  {
600  m_array.Remove( const_cast<iterator>( i ), const_cast<iterator>( j ) );
601  }
602 
612  void RemoveFirst( size_type n = 1 )
613  {
614  m_array.RemoveFirst( n );
615  }
616 
626  void RemoveLast( size_type n = 1 )
627  {
628  m_array.RemoveLast( n );
629  }
630 
642  {
643  m_array.Truncate( const_cast<iterator>( i ) );
644  }
645 
650  void Shrink( size_type n = 1 )
651  {
652  m_array.Shrink( n );
653  }
654 
657  void Remove( const T& v )
658  {
659  const_iterator i = pcl::BinarySearch( Begin(), End(), v );
660  if ( i != End() )
661  Remove( i, pcl::InsertionPoint( i+1, End(), v ) );
662  }
663 
666  void Clear()
667  {
668  m_array.Clear();
669  }
670 
673  void Reserve( size_type n )
674  {
675  m_array.Reserve( n );
676  }
677 
680  void Squeeze()
681  {
682  m_array.Squeeze();
683  }
684 
688  void Fill( const T& v )
689  {
690  m_array.Fill( v );
691  }
692 
695  template <class F>
696  void Apply( F f ) const
697  {
698  pcl::Apply( Begin(), End(), f );
699  }
700 
703  template <class F>
705  {
706  return pcl::FirstThat( Begin(), End(), f );
707  }
708 
711  template <class F>
713  {
714  return pcl::LastThat( Begin(), End(), f );
715  }
716 
719  size_type Count( const T& v ) const
720  {
721  const_iterator i = pcl::BinarySearch( Begin(), End(), v );
722  return (i != End()) ? pcl::InsertionPoint( i+1, End(), v ) - i : 0;
723  }
724 
727  template <class BP>
728  size_type Count( const T& v, BP p ) const
729  {
730  return m_array.Count( v, p );
731  }
732 
735  template <class UP>
736  size_type CountIf( UP p ) const
737  {
738  return m_array.CountIf( p );
739  }
740 
744  {
745  return Begin();
746  }
747 
750  template <class BP>
751  const_iterator MinItem( BP p ) const
752  {
753  return pcl::MinItem( Begin(), End(), p );
754  }
755 
759  {
760  return IsEmpty() ? End() : End()-1;
761  }
762 
765  template <class BP>
766  const_iterator MaxItem( BP p ) const
767  {
768  return pcl::MaxItem( Begin(), End(), p );
769  }
770 
773  const_iterator Search( const T& v ) const
774  {
775  return pcl::BinarySearch( Begin(), End(), v );
776  }
777 
780  template <class BP>
781  const_iterator Search( const T& v, BP p ) const
782  {
783  return m_array.Search( v, p );
784  }
785 
788  const_iterator SearchLast( const T& v ) const
789  {
790  return pcl::BinarySearchLast( Begin(), End(), v );
791  }
792 
795  template <class BP>
796  const_iterator SearchLast( const T& v, BP p ) const
797  {
798  return m_array.SearchLast( v, p );
799  }
800 
803  bool Contains( const T& v ) const
804  {
805  return Search( v ) != End();
806  }
807 
810  template <class BP>
811  bool Contains( const T& v, BP p ) const
812  {
813  return Search( v, p ) != End();
814  }
815 
818  void Sort()
819  {
820  m_array.Sort();
821  }
822 
826  friend void Swap( SortedArray& x1, SortedArray& x2 )
827  {
828  pcl::Swap( x1.m_array, x2.m_array );
829  }
830 
835  friend bool operator ==( const SortedArray& x1, const SortedArray& x2 )
836  {
837  return x1.m_array == x2.m_array;
838  }
839 
844  friend bool operator ==( const SortedArray& x1, const array_implementation& x2 )
845  {
846  return x1.m_array == x2;
847  }
848 
853  friend bool operator ==( const array_implementation& x1, const SortedArray& x2 )
854  {
855  return x1 == x2.m_array;
856  }
857 
863  friend bool operator <( const SortedArray& x1, const SortedArray& x2 )
864  {
865  return x1.m_array < x2.m_array;
866  }
867 
872  friend bool operator <( const SortedArray& x1, const array_implementation& x2 )
873  {
874  return x1.m_array < x2;
875  }
876 
881  friend bool operator <( const array_implementation& x1, const SortedArray& x2 )
882  {
883  return x1 < x2.m_array;
884  }
885 
902  template <class S, typename SP>
903  S& ToSeparated( S& s, SP separator ) const
904  {
905  return m_array.ToSeparated( s, separator );
906  }
907 
930  template <class S, typename SP, class AF>
931  S& ToSeparated( S& s, SP separator, AF append ) const
932  {
933  return m_array.ToSeparated( s, separator, append );
934  }
935 
944  template <class S>
945  S& ToCommaSeparated( S& s ) const
946  {
947  return m_array.ToCommaSeparated( s );
948  }
949 
958  template <class S>
959  S& ToSpaceSeparated( S& s ) const
960  {
961  return m_array.ToSpaceSeparated( s );
962  }
963 
972  template <class S>
973  S& ToTabSeparated( S& s ) const
974  {
975  return m_array.ToTabSeparated( s );
976  }
977 
986  template <class S>
987  S& ToNewLineSeparated( S& s ) const
988  {
989  return m_array.ToNewLineSeparated( s );
990  }
991 
1000  uint64 Hash64( uint64 seed = 0 ) const
1001  {
1002  return m_array.Hash64( seed );
1003  }
1004 
1013  uint32 Hash32( uint32 seed = 0 ) const
1014  {
1015  return m_array.Hash32( seed );
1016  }
1017 
1022  uint64 Hash( uint64 seed = 0 ) const
1023  {
1024  return Hash64( seed );
1025  }
1026 
1027  // -------------------------------------------------------------------------
1028 
1029 private:
1030 
1031  array_implementation m_array;
1032 };
1033 
1034 // ----------------------------------------------------------------------------
1035 
1044 template <class T, class A, class V> inline
1045 SortedArray<T,A>& operator <<( SortedArray<T,A>& x, const V& v )
1046 {
1047  x.Add( T( v ) );
1048  return x;
1049 }
1050 
1059 template <class T, class A, class V> inline
1060 SortedArray<T,A>& operator <<( SortedArray<T,A>&& x, const V& v )
1061 {
1062  x.Add( T( v ) );
1063  return x;
1064 }
1065 
1071 template <class T, class A> inline
1072 SortedArray<T,A>& operator <<( SortedArray<T,A>& x1, const SortedArray<T,A>& x2 )
1073 {
1074  x1.Add( x2 );
1075  return x1;
1076 }
1077 
1083 template <class T, class A> inline
1084 SortedArray<T,A>& operator <<( SortedArray<T,A>&& x1, const SortedArray<T,A>& x2 )
1085 {
1086  x1.Add( x2 );
1087  return x1;
1088 }
1089 
1095 template <class T, class A> inline
1096 SortedArray<T,A>& operator <<( SortedArray<T,A>& x1, const Array<T,A>& x2 )
1097 {
1098  x1.Add( x2 );
1099  return x1;
1100 }
1101 
1107 template <class T, class A> inline
1108 SortedArray<T,A>& operator <<( SortedArray<T,A>&& x1, const Array<T,A>& x2 )
1109 {
1110  x1.Add( x2 );
1111  return x1;
1112 }
1113 
1114 // ----------------------------------------------------------------------------
1115 
1116 } // pcl
1117 
1118 #endif // __PCL_SortedArray_h
1119 
1120 // ----------------------------------------------------------------------------
1121 // EOF pcl/SortedArray.h - Released 2024-06-18T15:48:54Z
Provides memory allocation for PCL containers.
Definition: Allocator.h:132
Generic dynamic array.
Definition: Array.h:100
iterator Begin()
Definition: Array.h:426
iterator End()
Definition: Array.h:451
A block_allocator
Definition: Array.h:105
T * iterator
Definition: Array.h:113
const T * const_iterator
Definition: Array.h:117
Root base class of all PCL sorted containers of objects.
Definition: Container.h:102
Reverse random access iterator.
Definition: Iterator.h:420
Generic dynamic sorted array.
Definition: SortedArray.h:83
void Shrink(size_type n=1)
Definition: SortedArray.h:650
SortedArray(const SortedArray &)=default
SortedArray(size_type n, const T &v)
Definition: SortedArray.h:133
bool IsValid() const
Definition: SortedArray.h:244
size_type Size() const
Definition: SortedArray.h:215
const_reverse_iterator ReverseBegin() const
Definition: SortedArray.h:349
typename array_implementation::block_allocator block_allocator
Definition: SortedArray.h:92
void UniquifyIterator(iterator &i)
Definition: SortedArray.h:383
SortedArray(SortedArray &&)=default
const allocator & Allocator() const
Definition: SortedArray.h:272
const_iterator SearchLast(const T &v, BP p) const
Definition: SortedArray.h:796
bool IsUnique() const
Definition: SortedArray.h:184
bool IsEmpty() const
Definition: SortedArray.h:251
friend void Swap(SortedArray &x1, SortedArray &x2)
Definition: SortedArray.h:826
void Remove(const T &v)
Definition: SortedArray.h:657
iterator MutableEnd()
Definition: SortedArray.h:342
typename array_implementation::allocator allocator
Definition: SortedArray.h:96
const_reverse_iterator ReverseEnd() const
Definition: SortedArray.h:363
bool Contains(const T &v, BP p) const
Definition: SortedArray.h:811
size_type Length() const
Definition: SortedArray.h:223
SortedArray(size_type n)
Definition: SortedArray.h:125
uint32 Hash32(uint32 seed=0) const
Definition: SortedArray.h:1013
void Assign(const SortedArray &x)
Definition: SortedArray.h:434
const_iterator End() const
Definition: SortedArray.h:335
void Transfer(array_implementation &&x)
Definition: SortedArray.h:496
void UniquifyIterators(iterator &i, iterator &j)
Definition: SortedArray.h:397
const_iterator begin() const
Definition: SortedArray.h:406
typename array_implementation::const_iterator const_iterator
Definition: SortedArray.h:104
size_type UpperBound() const
Definition: SortedArray.h:265
const_iterator At(size_type i) const
Definition: SortedArray.h:286
size_type LowerBound() const
Definition: SortedArray.h:258
void Assign(const array_implementation &x)
Definition: SortedArray.h:472
void Transfer(SortedArray &&x)
Definition: SortedArray.h:457
void Add(const SortedArray &x)
Definition: SortedArray.h:535
const_iterator Search(const T &v) const
Definition: SortedArray.h:773
iterator MutableAt(size_type i)
Definition: SortedArray.h:293
void SetAllocator(const allocator &a)
Definition: SortedArray.h:279
void Truncate(const_iterator i)
Definition: SortedArray.h:641
void Fill(const T &v)
Definition: SortedArray.h:688
size_type Available() const
Definition: SortedArray.h:237
typename array_implementation::reverse_iterator reverse_iterator
Definition: SortedArray.h:108
const_iterator MaxItem() const
Definition: SortedArray.h:758
void Apply(F f) const
Definition: SortedArray.h:696
void Remove(const_iterator i, size_type n=1)
Definition: SortedArray.h:591
const_iterator Search(const T &v, BP p) const
Definition: SortedArray.h:781
reverse_iterator MutableReverseBegin()
Definition: SortedArray.h:356
iterator Release()
Definition: SortedArray.h:528
void RemoveFirst(size_type n=1)
Definition: SortedArray.h:612
const_iterator FirstThat(F f) const
Definition: SortedArray.h:704
void Assign(FI i, FI j)
Definition: SortedArray.h:512
SortedArray(FI i, FI j)
Definition: SortedArray.h:143
SortedArray()=default
size_type CountIf(UP p) const
Definition: SortedArray.h:736
typename array_implementation::const_reverse_iterator const_reverse_iterator
Definition: SortedArray.h:112
const_iterator SearchLast(const T &v) const
Definition: SortedArray.h:788
void Assign(const T &v, size_type n=1)
Definition: SortedArray.h:504
bool IsAliasOf(const SortedArray &x) const
Definition: SortedArray.h:194
void Add(const Array< T, A > &x)
Definition: SortedArray.h:547
const_iterator Begin() const
Definition: SortedArray.h:321
void Transfer(SortedArray &x)
Definition: SortedArray.h:450
size_type Count(const T &v) const
Definition: SortedArray.h:719
const_iterator Add(const T &v, size_type n=1)
Definition: SortedArray.h:554
uint64 Hash(uint64 seed=0) const
Definition: SortedArray.h:1022
void Transfer(array_implementation &x)
Definition: SortedArray.h:488
reverse_iterator MutableReverseEnd()
Definition: SortedArray.h:370
void Reserve(size_type n)
Definition: SortedArray.h:673
const_iterator LastThat(F f) const
Definition: SortedArray.h:712
const_iterator end() const
Definition: SortedArray.h:414
uint64 Hash64(uint64 seed=0) const
Definition: SortedArray.h:1000
const_iterator MinItem() const
Definition: SortedArray.h:743
void Import(iterator i, iterator j)
Definition: SortedArray.h:520
const_iterator MaxItem(BP p) const
Definition: SortedArray.h:766
iterator MutableIterator(const_iterator i)
Definition: SortedArray.h:300
typename array_implementation::iterator iterator
Definition: SortedArray.h:100
iterator MutableBegin()
Definition: SortedArray.h:328
bool Contains(const T &v) const
Definition: SortedArray.h:803
void Remove(const_iterator i, const_iterator j)
Definition: SortedArray.h:598
void RemoveLast(size_type n=1)
Definition: SortedArray.h:626
size_type Count(const T &v, BP p) const
Definition: SortedArray.h:728
const_iterator MinItem(BP p) const
Definition: SortedArray.h:751
void Add(FI i, FI j)
Definition: SortedArray.h:562
size_type Capacity() const
Definition: SortedArray.h:230
SortedArray(std::initializer_list< T1 > l)
Definition: SortedArray.h:158
Array< T, A > & operator<<(Array< T, A > &x, const V &v)
Definition: Array.h:2295
bool operator==(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
Definition: Array.h:2267
bool operator<(const Array< T, A > &x1, const Array< T, A > &x2) noexcept
Definition: Array.h:2278
Complex< T1 > operator*(const Complex< T1 > &c1, const Complex< T2 > &c2) noexcept
Definition: Complex.h:548
uint64 Hash64(const void *data, size_type size, uint64 seed=0) noexcept
Definition: Math.h:4750
void Swap(GenericPoint< T > &p1, GenericPoint< T > &p2) noexcept
Definition: Point.h:1459
unsigned long long uint64
Definition: Defs.h:682
unsigned int uint32
Definition: Defs.h:666
FI BinarySearch(FI i, FI j, const T &v) noexcept
Definition: Search.h:170
FI BinarySearchLast(FI i, FI j, const T &v) noexcept
Definition: Search.h:238
FI1 Search(FI1 i1, FI1 j1, FI2 i2, FI2 j2) noexcept
Definition: Search.h:397
FI InsertionPoint(FI i, FI j, const T &v) noexcept
Definition: Search.h:326
size_t size_type
Definition: Defs.h:609
void Sort(BI i, BI j)
Definition: Sort.h:520
BI LastThat(BI i, BI j, UP p) noexcept(noexcept(p))
Definition: Utility.h:350
FI MinItem(FI i, FI j) noexcept
Definition: Utility.h:441
FI MaxItem(FI i, FI j) noexcept
Definition: Utility.h:479
void Apply(FI i, FI j, F f) noexcept(noexcept(f))
Definition: Utility.h:249
FI FirstThat(FI i, FI j, UP p) noexcept(noexcept(p))
Definition: Utility.h:316
PCL root namespace.
Definition: AbstractImage.h:77