ReferenceArray.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/ReferenceArray.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_ReferenceArray_h
#define __PCL_ReferenceArray_h
 
 
#include <pcl/Diagnostics.h>
 
#include <pcl/Allocator.h>
#include <pcl/Container.h>
#include <pcl/IndirectArray.h>
#include <pcl/Iterator.h>
#include <pcl/StandardAllocator.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
template <typename T, class A = StandardAllocator>
class PCL_CLASS ReferenceArray : public DirectContainer<T>
{
public:
 
   using array_implementation = IndirectArray<T,A>;
 
   using block_allocator = typename array_implementation::block_allocator;
 
   using allocator = typename array_implementation::allocator;
 
   using indirect_iterator = typename array_implementation::iterator;
 
   using const_indirect_iterator = typename array_implementation::const_iterator;
 
   class iterator : public Iterator<RandomAccessIterator, T>
   {
   public:
 
      using iterator_base = Iterator<RandomAccessIterator, T>;
      using iterator_class = typename iterator_base::iterator_class;
      using item_type = typename iterator_base::item_type;
 
      iterator() = default;
 
      iterator( const iterator& ) = default;
 
      iterator( std::nullptr_t ) : it( nullptr )
      {
      }
 
      iterator& operator =( const iterator& ) = default;
 
      T* Pointer() const
      {
         return *it;
      }
 
      operator T*() const
      {
         return *it;
      }
 
      T& operator *() const
      {
         return **it;
      }
 
      T* operator ->() const
      {
         return *it;
      }
 
      iterator& operator ++()
      {
         ++it;
         return *this;
      }
 
      iterator operator ++( int )
      {
         indirect_iterator it0 = it;
         ++it;
         return it0;
      }
 
      iterator& operator --()
      {
         --it;
         return *this;
      }
 
      iterator operator --( int )
      {
         indirect_iterator it0 = it;
         --it;
         return it0;
      }
 
      iterator& operator +=( distance_type d )
      {
         it += d;
         return *this;
      }
 
      iterator& operator -=( distance_type d )
      {
         it -= d;
         return *this;
      }
 
      iterator operator +( distance_type d ) const
      {
         return iterator( it + d );
      }
 
      iterator operator -( distance_type d ) const
      {
         return iterator( it - d );
      }
 
      distance_type operator -( const iterator& i ) const
      {
         return it - i.it;
      }
 
      bool operator ==( const iterator& i ) const
      {
         return it == i.it;
      }
 
      bool operator <( const iterator& i ) const
      {
         return it < i.it;
      }
 
   private:
 
      indirect_iterator it = nullptr;
 
      explicit
      iterator( indirect_iterator i ) : it( i )
      {
      }
 
      friend class ReferenceArray<T,A>;
      friend class ReferenceArray<T,A>::const_iterator;
   };
 
   class const_iterator : public Iterator<RandomAccessIterator, T>
   {
   public:
 
      using iterator_base = Iterator<RandomAccessIterator, T>;
      using iterator_class = typename iterator_base::iterator_class;
      using item_type = typename iterator_base::item_type;
 
      const_iterator() = default;
 
      const_iterator( const iterator& i ) : it( i.it )
      {
      }
 
      const_iterator( std::nullptr_t ) : it( nullptr )
      {
      }
 
      const_iterator( const const_iterator& ) = default;
 
      const_iterator& operator =( const const_iterator& ) = default;
 
      const_iterator& operator =( const iterator& i )
      {
         it = i.it;
         return *this;
      }
 
      const T* Pointer() const
      {
         return *it;
      }
 
      operator const T*() const
      {
         return *it;
      }
 
      const T& operator *() const
      {
         return **it;
      }
 
      const T* operator ->() const
      {
         return *it;
      }
 
      const_iterator& operator ++()
      {
         ++it;
         return *this;
      }
 
      const_iterator operator ++( int )
      {
         const_indirect_iterator it0 = it;
         ++it;
         return it0;
      }
 
      const_iterator& operator --()
      {
         --it;
         return *this;
      }
 
      const_iterator operator --( int )
      {
         const_indirect_iterator it0 = it;
         --it;
         return it0;
      }
 
      const_iterator& operator +=( distance_type d )
      {
         it += d;
         return *this;
      }
 
      const_iterator& operator -=( distance_type d )
      {
         it -= d;
         return *this;
      }
 
      const_iterator operator +( distance_type d ) const
      {
         return const_iterator( it + d );
      }
 
      const_iterator operator -( distance_type d ) const
      {
         return const_iterator( it - d );
      }
 
      distance_type operator -( const const_iterator& i ) const
      {
         return it - i.it;
      }
 
      distance_type operator -( const iterator& i ) const
      {
         return it - i.it;
      }
 
      bool operator ==( const const_iterator& i ) const
      {
         return it == i.it;
      }
 
      bool operator ==( const iterator& i ) const
      {
         return it == i.it;
      }
 
      bool operator <( const const_iterator& i ) const
      {
         return it < i.it;
      }
 
      bool operator <( const iterator& i ) const
      {
         return it < i.it;
      }
 
   private:
 
      const_indirect_iterator it = nullptr;
 
      explicit
      const_iterator( const_indirect_iterator i ) : it( i )
      {
      }
 
      friend class ReferenceArray<T,A>;
   };
 
   using reverse_iterator = ReverseRandomAccessIterator<iterator, T>;
 
   using const_reverse_iterator = ReverseRandomAccessIterator<const_iterator, const T>;
 
   // -------------------------------------------------------------------------
 
   ReferenceArray() = default;
 
   ReferenceArray( size_type n, const T* p )
   {
      PCL_PRECONDITION( p != nullptr )
      if ( p != nullptr )
         m_array = array_implementation( n, p );
   }
 
   template <class FI>
   ReferenceArray( FI i, FI j )
   {
      for ( ; i != j; ++i )
         if ( *i != nullptr )
            m_array.Append( *i );
   }
 
   ReferenceArray( const ReferenceArray& ) = default;
 
   ReferenceArray( ReferenceArray&& ) = default;
 
   ~ReferenceArray()
   {
   }
 
   bool IsUnique() const
   {
      return m_array.IsUnique();
   }
 
   bool IsAliasOf( const ReferenceArray& x ) const
   {
      return m_array.IsAliasOf( x.m_array );
   }
 
   void EnsureUnique()
   {
      m_array.EnsureUnique();
   }
 
   size_type Size() const
   {
      return m_array.Size();
   }
 
   size_type Length() const
   {
      return m_array.Length();
   }
 
   size_type Capacity() const
   {
      return m_array.Capacity();
   }
 
   size_type Available() const
   {
      return m_array.Available();
   }
 
   bool IsValid() const
   {
      return m_array.IsValid();
   }
 
   bool IsEmpty() const
   {
      return m_array.IsEmpty();
   }
 
   size_type LowerBound() const
   {
      return m_array.LowerBound();
   }
 
   size_type UpperBound() const
   {
      return m_array.UpperBound();
   }
 
   const allocator& Allocator() const
   {
      return m_array.Allocator();
   }
 
   void SetAllocator( const allocator& a )
   {
      m_array.SetAllocator( a );
   }
 
   iterator At( size_type i )
   {
      return iterator( m_array.At( i ) );
   }
 
   const_iterator At( size_type i ) const
   {
      return const_iterator( m_array.At( i ) );
   }
 
   iterator MutableIterator( const_iterator i )
   {
      return iterator( m_array.MutableIterator( i.it ) );
   }
 
   T& operator []( size_type i )
   {
      return *m_array[i];
   }
 
   const T& operator []( size_type i ) const
   {
      return *m_array[i];
   }
 
   T& operator *()
   {
      return **m_array.Begin();
   }
 
   const T& operator *() const
   {
      return **m_array.Begin();
   }
 
   iterator Begin()
   {
      return iterator( m_array.Begin() );
   }
 
   const_iterator Begin() const
   {
      return const_iterator( m_array.Begin() );
   }
 
   const_iterator ConstBegin() const
   {
      return const_iterator( m_array.ConstBegin() );
   }
 
   iterator End()
   {
      return iterator( m_array.End() );
   }
 
   const_iterator End() const
   {
      return const_iterator( m_array.End() );
   }
 
   const_iterator ConstEnd() const
   {
      return const_iterator(  m_array.ConstEnd() );
   }
 
   reverse_iterator ReverseBegin()
   {
      return iterator( m_array.End()-1 );
   }
 
   const_reverse_iterator ReverseBegin() const
   {
      return const_iterator( m_array.End()-1 );
   }
 
   const_reverse_iterator ConstReverseBegin() const
   {
      PCL_PRECONDITION( !IsEmpty() )
      return const_iterator( m_array.End()-1 );
   }
 
   reverse_iterator ReverseEnd()
   {
      PCL_PRECONDITION( !IsEmpty() )
      return iterator( m_array.Begin()-1 );
   }
 
   const_reverse_iterator ReverseEnd() const
   {
      PCL_PRECONDITION( !IsEmpty() )
      return const_iterator( m_array.Begin()-1 );
   }
 
   const_reverse_iterator ConstReverseEnd() const
   {
      PCL_PRECONDITION( !IsEmpty() )
      return const_iterator( m_array.Begin()-1 );
   }
 
   T& First()
   {
      return **m_array.Begin();
   }
 
   const T& First() const
   {
      return **m_array.Begin();
   }
 
   T& Last()
   {
      return **m_array.ReverseBegin();
   }
 
   const T& Last() const
   {
      return **m_array.ReverseBegin();
   }
 
   void UniquifyIterator( iterator& i )
   {
      m_array.UniquifyIterator( i.it );
   }
 
   void UniquifyIterators( iterator& i, iterator& j )
   {
      m_array.UniquifyIterators( i.it, j.it );
   }
 
#ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
   iterator begin()
   {
      return Begin();
   }
 
   const_iterator begin() const
   {
      return Begin();
   }
 
   iterator end()
   {
      return End();
   }
 
   const_iterator end() const
   {
      return End();
   }
#endif   // !__PCL_NO_STL_COMPATIBLE_ITERATORS
 
   ReferenceArray& operator =( const ReferenceArray& x )
   {
      Assign( x );
      return *this;
   }
 
   void Assign( const ReferenceArray& x )
   {
      m_array.Assign( x.m_array );
   }
 
   ReferenceArray& operator =( ReferenceArray&& x )
   {
      Transfer( x );
      return *this;
   }
 
   void Transfer( ReferenceArray& x )
   {
      m_array.Transfer( x.m_array );
   }
 
   void Transfer( ReferenceArray&& x )
   {
      m_array.Transfer( std::move( x.m_array ) );
   }
 
   void Assign( const T* p, size_type n = 1 )
   {
      if ( p != nullptr )
         m_array.Assign( p, n );
      else
         m_array.Clear();
   }
 
   template <class FI>
   void Assign( FI i, FI j )
   {
      m_array.Clear();
      for ( ; i != j; ++i )
         if ( *i != nullptr )
            m_array.Append( *i );
   }
 
   template <class C>
   void CloneAssign( const C& x )
   {
      PCL_ASSERT_CONTAINER( C, T );
      CloneObjects( x, (C*)nullptr );
   }
 
   void Import( iterator i, iterator j )
   {
      m_array.Import( i.it, j.it );
   }
 
   indirect_iterator Release()
   {
      return m_array.Release();
   }
 
   iterator Insert( const_iterator i, const ReferenceArray& x )
   {
      return iterator( m_array.Insert( i.it, x.m_array ) );
   }
 
   iterator Insert( const_iterator i, const T* p, size_type n = 1 )
   {
      return (p != nullptr) ? iterator( m_array.Insert( i.it, p, n ) ) :
                              iterator( const_cast<indirect_iterator>( i.it ) );
   }
 
   template <class FI>
   iterator Insert( const_iterator i, FI p, FI q )
   {
      const_indirect_iterator it = i.it;
      for ( ; p != q; ++p )
         if ( *p != nullptr )
            it = m_array.Insert( it, *p );
      return iterator( const_cast<indirect_iterator>( it ) );
   }
 
   void Append( const ReferenceArray& x )
   {
      m_array.Append( x.m_array );
   }
 
   void Append( const T* p, size_type n = 1 )
   {
      if ( p != nullptr )
         m_array.Append( p, n );
   }
 
   template <class FI>
   void Append( FI p, FI q )
   {
      for ( ; p != q; ++p )
         if ( *p != nullptr )
            m_array.Append( *p );
   }
 
   void Prepend( const ReferenceArray& x )
   {
      m_array.Prepend( x.m_array );
   }
 
   void Prepend( const T* p, size_type n = 1 )
   {
      if ( p != nullptr )
         m_array.Prepend( p, n );
   }
 
   template <class FI>
   void Prepend( FI p, FI q )
   {
      for ( ; p != q; ++p )
         if ( *p != nullptr )
            m_array.Prepend( *p );
   }
 
   void Add( const ReferenceArray& x )
   {
      Append( x );
   }
 
   void Add( const T* p, size_type n = 1 )
   {
      Append( p, n );
   }
 
   template <class FI>
   void Add( FI i, FI j )
   {
      Append( i, j );
   }
 
   void Remove( const_iterator i, size_type n = 1 )
   {
      m_array.Remove( i.it, n );
   }
 
   void Remove( const_iterator i, const_iterator j )
   {
      m_array.Remove( i.it, j.it );
   }
 
   void RemoveFirst( size_type n = 1 )
   {
      m_array.RemoveFirst( n );
   }
 
   void RemoveLast( size_type n = 1 )
   {
      m_array.RemoveLast( n );
   }
 
   void Truncate( const_iterator i )
   {
      m_array.Truncate( i.it );
   }
 
   void Shrink( size_type n = 1 )
   {
      m_array.Shrink( n );
   }
 
   void Remove( const T& v )
   {
      m_array.Remove( v );
   }
 
   template <class BP>
   void Remove( const T& v, BP p )
   {
      m_array.Remove( v, p );
   }
 
   void RemovePointer( const T* p )
   {
      m_array.Remove( p );
   }
 
   void Clear()
   {
      m_array.Clear();
   }
 
   void Destroy( iterator i, size_type n = 1 )
   {
      m_array.Destroy( i.it, n );
   }
 
   void Destroy( iterator i, iterator j )
   {
      m_array.Destroy( i.it, j.it );
   }
 
   void Destroy( const T& v )
   {
      m_array.Destroy( v );
   }
 
   template <class BP>
   void Destroy( const T& v, BP p )
   {
      m_array.Destroy( v, p );
   }
 
   void Destroy()
   {
      m_array.Destroy();
   }
 
   iterator Replace( const_iterator i, const_iterator j, const ReferenceArray& x )
   {
      return iterator( m_array.Replace( i.it, j.it, x.m_array ) );
   }
 
   iterator Replace( const_iterator i, const_iterator j, const T* p, size_type n = 1 )
   {
      return iterator( m_array.Replace( i.it, j.it, p, (p != nullptr) ? n : size_type( 0 ) ) );
   }
 
   template <class FI>
   iterator Replace( const_iterator i, const_iterator j, FI p, FI q )
   {
      array_implementation m;
      for ( ; p != q; ++p )
         if ( *p != nullptr )
            m.Append( *p );
      return iterator( m_array.Replace( i.it, j.it, m ) );
   }
 
   void Reserve( size_type n )
   {
      m_array.Reserve( n );
   }
 
   void Squeeze()
   {
      m_array.Squeeze();
   }
 
   void Fill( const T& v )
   {
      pcl::Fill( Begin(), End(), v );
   }
 
   template <class F>
   void Apply( F f )
   {
      pcl::Apply( Begin(), End(), f );
   }
 
   template <class F>
   void Apply( F f ) const
   {
      pcl::Apply( Begin(), End(), f );
   }
 
   template <class F>
   const_iterator FirstThat( F f ) const
   {
      return const_iterator( pcl::FirstThat( Begin(), End(), f ).it );
   }
 
   template <class F>
   iterator FirstThat( F f )
   {
      return iterator( pcl::FirstThat( Begin(), End(), f ).it );
   }
 
   template <class F>
   const_iterator LastThat( F f ) const
   {
      return const_iterator( pcl::LastThat( Begin(), End(), f ).it );
   }
 
   template <class F>
   iterator LastThat( F f )
   {
      return iterator( pcl::LastThat( Begin(), End(), f ).it );
   }
 
   size_type Count( const T& v ) const
   {
      return pcl::Count( Begin(), End(), v );
   }
 
   size_type Count( const T* p ) const
   {
      return m_array.Count( p );
   }
 
   template <class BP>
   size_type Count( const T& v, BP p ) const
   {
      return pcl::Count( Begin(), End(), v, p );
   }
 
   template <class UP>
   size_type CountIf( UP p ) const
   {
      return pcl::CountIf( Begin(), End(), p );
   }
 
   const_iterator MinItem() const
   {
      return const_iterator( pcl::MinItem( Begin(), End() ).it );
   }
 
   iterator MinItem()
   {
      return iterator( pcl::MinItem( Begin(), End() ).it );
   }
 
   template <class BP>
   const_iterator MinItem( BP p ) const
   {
      return const_iterator( pcl::MinItem( Begin(), End(), p ).it );
   }
 
   template <class BP>
   iterator MinItem( BP p )
   {
      return iterator( pcl::MinItem( Begin(), End(), p ).it );
   }
 
   const_iterator MaxItem() const
   {
      return const_iterator( pcl::MaxItem( Begin(), End() ).it );
   }
 
   iterator MaxItem()
   {
      return iterator( pcl::MaxItem( Begin(), End() ).it );
   }
 
   template <class BP>
   const_iterator MaxItem( BP p ) const
   {
      return const_iterator( pcl::MaxItem( Begin(), End(), p ).it );
   }
 
   template <class BP>
   iterator MaxItem( BP p )
   {
      return iterator( pcl::MaxItem( Begin(), End(), p ).it );
   }
 
   void Reverse()
   {
      m_array.Reverse();
   }
 
   void Rotate( distance_type n )
   {
      m_array.Rotate( n );
   }
 
   void ShiftLeft( const T* p, size_type n = 1 )
   {
      m_array.ShiftLeft( p, n );
   }
 
   void ShiftRight( const T* p, size_type n = 1 )
   {
      m_array.ShiftRight( p, n );
   }
 
   const_iterator Search( const T& v ) const
   {
      return const_iterator( pcl::LinearSearch( Begin(), End(), v ).it );
   }
 
   iterator Search( const T& v )
   {
      return iterator( pcl::LinearSearch( Begin(), End(), v ).it );
   }
 
   const_iterator Search( const T* p ) const
   {
      return const_iterator( m_array.Search( p ) );
   }
 
   iterator Search( const T* p )
   {
      return iterator( m_array.Search( p ) );
   }
 
   template <class BP>
   const_iterator Search( const T& v, BP p ) const
   {
      return const_iterator( pcl::LinearSearch( Begin(), End(), v, p ).it );
   }
 
   template <class BP>
   iterator Search( const T& v, BP p )
   {
      return iterator( pcl::LinearSearch( Begin(), End(), v, p ).it );
   }
 
   const_iterator SearchLast( const T& v ) const
   {
      return const_iterator( pcl::LinearSearchLast( Begin(), End(), v ).it );
   }
 
   iterator SearchLast( const T& v )
   {
      return iterator( pcl::LinearSearchLast( Begin(), End(), v ).it );
   }
 
   const_iterator SearchLast( const T* p ) const
   {
      return const_iterator( m_array.SearchLast( p ) );
   }
 
   iterator SearchLast( const T* p )
   {
      return iterator( m_array.SearchLast( p ) );
   }
 
   template <class BP>
   const_iterator SearchLast( const T& v, BP p ) const
   {
      return const_iterator( pcl::LinearSearchLast( Begin(), End(), v, p ).it );
   }
 
   template <class BP>
   iterator SearchLast( const T& v, BP p )
   {
      return iterator( pcl::LinearSearchLast( Begin(), End(), v, p ).it );
   }
 
   template <class FI>
   const_iterator SearchSubset( FI i, FI j ) const
   {
      return const_iterator( pcl::Search( Begin(), End(), i, j ).it );
   }
 
   template <class FI>
   iterator SearchSubset( FI i, FI j )
   {
      return iterator( pcl::Search( Begin(), End(), i, j ).it );
   }
 
   template <class FI, class BP>
   const_iterator SearchSubset( FI i, FI j, BP p ) const
   {
      return const_iterator( pcl::Search( Begin(), End(), i, j, p ).it );
   }
 
   template <class FI, class BP>
   iterator SearchSubset( FI i, FI j, BP p )
   {
      return iterator( pcl::Search( Begin(), End(), i, j, p ).it );
   }
 
   template <class C>
   const_iterator SearchSubset( const C& c ) const
   {
      return const_iterator( pcl::Search( Begin(), End(), c.Begin(), c.End() ).it );
   }
 
   template <class C>
   iterator SearchSubset( const C& c )
   {
      return iterator( pcl::Search( Begin(), End(), c.Begin(), c.End() ).it );
   }
 
   template <class C, class BP>
   const_iterator SearchSubset( const C& c, BP p ) const
   {
      return const_iterator( pcl::Search( Begin(), End(), c.Begin(), c.End(), p ).it );
   }
 
   template <class C, class BP>
   iterator SearchSubset( const C& c, BP p )
   {
      return iterator( pcl::Search( Begin(), End(), c.Begin(), c.End(), p ).it );
   }
 
   template <class BI>
   const_iterator SearchLastSubset( BI i, BI j ) const
   {
      return const_iterator( pcl::SearchLast( Begin(), End(), i, j ).it );
   }
 
   template <class BI>
   iterator SearchLastSubset( BI i, BI j )
   {
      return iterator( pcl::SearchLast( Begin(), End(), i, j ).it );
   }
 
   template <class BI, class BP>
   const_iterator SearchLastSubset( BI i, BI j, BP p ) const
   {
      return const_iterator( pcl::SearchLast( Begin(), End(), i, j, p ).it );
   }
 
   template <class BI, class BP>
   iterator SearchLastSubset( BI i, BI j, BP p )
   {
      return iterator( pcl::SearchLast( Begin(), End(), i, j, p ).it );
   }
 
   template <class C>
   const_iterator SearchLastSubset( const C& c ) const
   {
      return const_iterator( pcl::SearchLast( Begin(), End(), c.Begin(), c.End() ).it );
   }
 
   template <class C>
   iterator SearchLastSubset( const C& c )
   {
      return iterator( pcl::SearchLast( Begin(), End(), c.Begin(), c.End() ).it );
   }
 
   template <class C, class BP>
   const_iterator SearchLastSubset( const C& c, BP p ) const
   {
      return const_iterator( pcl::SearchLast( Begin(), End(), c.Begin(), c.End(), p ).it );
   }
 
   template <class C, class BP>
   iterator SearchLastSubset( const C& c, BP p )
   {
      return iterator( pcl::SearchLast( Begin(), End(), c.Begin(), c.End(), p ).it );
   }
 
   bool Contains( const T& v ) const
   {
      return Search( v ) != End();
   }
 
   bool Contains( const T* p ) const
   {
      return m_array.Contains( p );
   }
 
   template <class BP>
   bool Contains( const T& v, BP p ) const
   {
      return Search( v, p ) != End();
   }
 
   template <class FI>
   iterator ContainsSubset( FI i, FI j ) const
   {
      return SearchSubset( i, j ) != End();
   }
 
   template <class FI, class BP>
   iterator ContainsSubset( FI i, FI j, BP p ) const
   {
      return SearchSubset( i, j, p ) != End();
   }
 
   template <class C>
   iterator ContainsSubset( const C& c ) const
   {
      return m_array.ContainsSubset( c );
   }
 
   template <class C, class BP>
   iterator ContainsSubset( const C& c, BP p ) const
   {
      return SearchSubset( c ) != End();
   }
 
   void Sort()
   {
      pcl::QuickSort( m_array.Begin(), m_array.End(),
                      []( const T* a, const T* b ){ return *a < *b; } );
   }
 
   template <class BP>
   void Sort( BP p )
   {
      pcl::QuickSort( m_array.Begin(), m_array.End(),
                      [p]( const T* a, const T* b ){ return p( *a, *b ); } );
   }
 
   friend void Swap( ReferenceArray& x1, ReferenceArray& x2 )
   {
      pcl::Swap( x1.m_array, x2.m_array );
   }
 
   template <class S, typename SP>
   S& ToSeparated( S& s, SP separator ) const
   {
      const_iterator i = Begin();
      if ( i < End() )
      {
         s.Append( S( *i ) );
         if ( ++i < End() )
            do
            {
               s.Append( separator );
               s.Append( S( *i ) );
            }
            while ( ++i < End() );
      }
      return s;
   }
 
   template <class S, typename SP, class AF>
   S& ToSeparated( S& s, SP separator, AF append ) const
   {
      const_iterator i = Begin();
      if ( i < End() )
      {
         append( s, S( *i ) );
         if ( ++i < End() )
         {
            S p( separator );
            do
            {
               append( s, p );
               append( s, S( *i ) );
            }
            while ( ++i < End() );
         }
      }
      return s;
   }
 
   template <class S>
   S& ToCommaSeparated( S& s ) const
   {
      return ToSeparated( s, ',' );
   }
 
   template <class S>
   S& ToSpaceSeparated( S& s ) const
   {
      return ToSeparated( s, ' ' );
   }
 
   template <class S>
   S& ToTabSeparated( S& s ) const
   {
      return ToSeparated( s, '\t' );
   }
 
   template <class S>
   S& ToNewLineSeparated( S& s ) const
   {
      return ToSeparated( s, '\n' );
   }
 
   uint64 Hash64( uint64 seed = 0 ) const
   {
      return m_array.Hash64( seed );
   }
 
   uint32 Hash32( uint32 seed = 0 ) const
   {
      return m_array.Hash32( seed );
   }
 
   uint64 Hash( uint64 seed = 0 ) const
   {
      return Hash64( seed );
   }
 
private:
 
   array_implementation m_array;
 
   template <class C>
   void CloneObjects( const C& x, DirectContainer<T>* )
   {
      m_array.CloneAssign( x );
   }
 
   template <class C>
   void CloneObjects( const C& x, IndirectContainer<T>* )
   {
      m_array.Clear();
      m_array.Reserve( x.Length() );
      allocator a;
      for ( typename C::const_iterator p = x.Begin(); p != x.End(); ++p )
         if ( *p != nullptr )
         {
            T* o = a.Allocate( 1 );
            pcl::Construct( o, **p, a );
            m_array.Append( o );
         }
   }
};
 
// ----------------------------------------------------------------------------
 
template <class T, class A> inline
bool operator ==( const ReferenceArray<T,A>& x1, const ReferenceArray<T,A>& x2 )
{
   return x1.Length() == x2.Length() && pcl::Equal( x1.Begin(), x2.Begin(), x2.End() );
}
 
template <class T, class A> inline
bool operator <( const ReferenceArray<T,A>& x1, const ReferenceArray<T,A>& x2 )
{
   return pcl::Compare( x1.Begin(), x1.End(), x2.Begin(), x2.End() ) < 0;
}
 
template <class T, class A, class V> inline
ReferenceArray<T,A>& operator <<( ReferenceArray<T,A>& x, const V* p )
{
   x.Append( static_cast<const T*>( p ) );
   return x;
}
 
template <class T, class A, class V> inline
ReferenceArray<T,A>& operator <<( ReferenceArray<T,A>&& x, const V* p )
{
   x.Append( static_cast<const T*>( p ) );
   return x;
}
 
template <class T, class A> inline
ReferenceArray<T,A>& operator <<( ReferenceArray<T,A>& x1, const ReferenceArray<T,A>& x2 )
{
   x1.Append( x2 );
   return x1;
}
 
template <class T, class A> inline
ReferenceArray<T,A>& operator <<( ReferenceArray<T,A>&& x1, const ReferenceArray<T,A>& x2 )
{
   x1.Append( x2 );
   return x1;
}
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_ReferenceArray_h
 
// ----------------------------------------------------------------------------
// EOF pcl/ReferenceArray.h - Released 2024-06-18T15:48:54Z