Iterator.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/Iterator.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_Iterator_h
#define __PCL_Iterator_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/Relational.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS ForwardIterator
{
};
 
class PCL_CLASS BidirectionalIterator : public ForwardIterator
{
};
 
class PCL_CLASS RandomAccessIterator : public BidirectionalIterator
{
};
 
// ----------------------------------------------------------------------------
 
template <class C, class T>
struct PCL_CLASS Iterator
{
   using iterator_class = C;  
   using item_type = T;       
};
 
// ----------------------------------------------------------------------------
 
template <class C, class T> inline
C IteratorClass( const Iterator<C,T>& )
{
   return C();
}
 
template <typename T> inline
RandomAccessIterator IteratorClass( const T* )
{
   return RandomAccessIterator();
}
 
// ----------------------------------------------------------------------------
 
template <class C, class T> inline
T* ItemType( const Iterator<C,T>& )
{
   return nullptr;
}
 
template <typename T> inline
T* ItemType( const T* )
{
   return nullptr;
}
 
// ----------------------------------------------------------------------------
 
template <class FI> inline
distance_type Distance( FI i, FI j )
{
   return __pcl_distance__( i, j, IteratorClass( i ) );
}
 
template <class FI> inline
distance_type __pcl_distance__( FI i, FI j, ForwardIterator )
{
   distance_type d = 0;
   for ( ; i != j; ++i, ++d ) {}
   return d;
}
 
template <class RI> inline
distance_type __pcl_distance__( RI i, RI j, RandomAccessIterator )
{
   return j - i;
}
 
// ----------------------------------------------------------------------------
 
template <class FI> inline
void Advance( FI& i, distance_type d )
{
   __pcl_advance__( i, d, IteratorClass( i ) );
}
 
template <class FI> inline
void __pcl_advance__( FI& i, distance_type d, ForwardIterator )
{
   PCL_PRECONDITION( d >= 0 )
   for ( ; d > 0; --d, ++i ) {}
}
 
template <class BI> inline
void __pcl_advance__( BI& i, distance_type d, BidirectionalIterator )
{
   if ( d > 0 )
      for ( ; ++i, --d > 0; ) {}
   else
      for ( ; d < 0; ++d, --i ) {}
}
 
template <class RI> inline
void __pcl_advance__( RI& i, distance_type d, RandomAccessIterator )
{
   i += d;
}
 
// ----------------------------------------------------------------------------
 
template <class FI> inline
void MoveForward( FI& i, size_type n )
{
   __pcl_move_forward__( i, n, IteratorClass( i ) );
}
 
template <class FI> inline
void __pcl_move_forward__( FI& i, size_type n, ForwardIterator )
{
   for ( ; n > 0; --n, ++i ) {}
}
 
template <class RI> inline
void __pcl_move_forward__( RI& i, size_type n, RandomAccessIterator )
{
   i += n;
}
 
// ----------------------------------------------------------------------------
 
template <class BI> inline
void MoveBackward( BI& i, size_type n )
{
   __pcl_move_backward__( i, n, IteratorClass( i ) );
}
 
template <class BI> inline
void __pcl_move_backward__( BI& i, size_type n, BidirectionalIterator )
{
   for ( ; n > 0; --n, --i ) {}
}
 
template <class RI> inline
void __pcl_move_backward__( RI& i, size_type n, RandomAccessIterator )
{
   i -= n;
}
 
// ----------------------------------------------------------------------------
 
template <class BI, class C, class T>
class PCL_CLASS ReverseIteratorBase : public pcl::Iterator<C,T>
{
public:
 
   ReverseIteratorBase() = default;
 
   ReverseIteratorBase( const ReverseIteratorBase& i )
      : pcl::Iterator<C,T>( i )
      , iterator( i.iterator )
   {
   }
 
   ReverseIteratorBase( const BI& i )
      : iterator( i )
   {
   }
 
   T& operator *() const
   {
      return (T&)*iterator;
   }
 
   BI operator ->() const
   {
      return this->Iterator();
   }
 
   operator BI() const
   {
      return this->Iterator();
   }
 
   BI Iterator() const
   {
      return iterator;
   }
 
protected:
 
   BI iterator;
 
   void PreIncrement()
   {
      --iterator;
   }
 
   BI PostIncrement()
   {
      BI tmp = iterator;
      --iterator;
      return tmp;
   }
 
   void PreDecrement()
   {
      ++iterator;
   }
 
   BI PostDecrement()
   {
      BI tmp = iterator;
      ++iterator;
      return tmp;
   }
};
 
template <class BI, class C, class T> inline
bool operator ==( const ReverseIteratorBase<BI,C,T>& i, const ReverseIteratorBase<BI,C,T>& j )
{
   return i.Iterator() == j.Iterator();
}
 
// ----------------------------------------------------------------------------
 
#define IMPLEMENT_INCDEC_OPERATORS                                         \
   __I__& operator ++()      { __R__::PreIncrement(); return *this; }      \
   __I__  operator ++( int ) { return __I__( __R__::PostIncrement() ); }   \
   __I__& operator --()      { __R__::PreDecrement(); return *this; }      \
   __I__  operator --( int ) { return __I__( __R__::PostDecrement() ); }
 
template <class BI, class T>
class PCL_CLASS ReverseBidirectionalIterator : public ReverseIteratorBase<BI,BidirectionalIterator,T>
{
   using __R__ = ReverseIteratorBase<BI,BidirectionalIterator,T>;
   using __I__ = ReverseBidirectionalIterator;
 
public:
 
   ReverseBidirectionalIterator() = default;
 
   ReverseBidirectionalIterator( const ReverseBidirectionalIterator& i )
      : __R__( i )
   {
   }
 
   ReverseBidirectionalIterator( const BI& i )
      : __R__( i )
   {
   }
 
   IMPLEMENT_INCDEC_OPERATORS
};
 
// ----------------------------------------------------------------------------
 
template <class RI, class T>
class PCL_CLASS ReverseRandomAccessIterator : public ReverseIteratorBase<RI,RandomAccessIterator,T>
{
   using __R__ = ReverseIteratorBase<RI,RandomAccessIterator,T>;
   using __I__ = ReverseRandomAccessIterator;
 
public:
 
   ReverseRandomAccessIterator() = default;
 
   ReverseRandomAccessIterator( const ReverseRandomAccessIterator& i )
      : __R__( i )
   {
   }
 
   ReverseRandomAccessIterator( const RI& i )
      : __R__( i )
   {
   }
 
   T& operator[]( size_type d ) const
   {
      return (T&)*(__R__::iterator - d);
   }
 
   ReverseRandomAccessIterator& operator +=( distance_type d )
   {
      __R__::iterator -= d;
      return *this;
   }
 
   ReverseRandomAccessIterator& operator -=( distance_type d )
   {
      __R__::iterator += d;
      return *this;
   }
 
   IMPLEMENT_INCDEC_OPERATORS
};
 
#undef IMPLEMENT_INCDEC_OPERATORS
 
template <class RI, class T> inline
bool operator <( const ReverseRandomAccessIterator<RI,T>& i, const ReverseRandomAccessIterator<RI,T>& j )
{
   return j.Iterator() < i.Iterator();
}
 
template <class RI, class T> inline
ReverseRandomAccessIterator<RI,T> operator +( const ReverseRandomAccessIterator<RI,T>& i, distance_type d )
{
   RI r = i.Iterator();
   return r -= d;
}
 
template <class RI, class T> inline
ReverseRandomAccessIterator<RI,T> operator +( distance_type d, const ReverseRandomAccessIterator<RI,T>& i )
{
   return i + d;
}
 
template <class RI, class T> inline
ReverseRandomAccessIterator<RI,T> operator -( const ReverseRandomAccessIterator<RI,T>& i, distance_type d )
{
   RI r = i.Iterator();
   return r += d;
}
 
template <class RI, class T> inline
distance_type operator -( const ReverseRandomAccessIterator<RI,T>& i, const ReverseRandomAccessIterator<RI,T>& j )
{
   return j.Iterator() - i.Iterator();
}
 
// ----------------------------------------------------------------------------
 
template <class C>
class PCL_CLASS ReverseIterable
{
public:
 
   using container = C;
 
   ReverseIterable( container& c )
      : m_container( c )
   {
   }
 
   ReverseIterable( const ReverseIterable& ) = default;
 
   auto Begin()
   {
      return m_container.ReverseBegin();
   }
 
   auto Begin() const
   {
      return m_container.ReverseBegin();
   }
 
   auto ConstBegin() const
   {
      return m_container.ConstReverseBegin();
   }
 
   auto End()
   {
      return m_container.ReverseEnd();
   }
 
   auto End() const
   {
      return m_container.ReverseEnd();
   }
 
   auto ConstEnd() const
   {
      return m_container.ConstReverseEnd();
   }
 
   auto ReverseBegin()
   {
      return m_container.Begin();
   }
 
   auto ReverseBegin() const
   {
      return m_container.Begin();
   }
 
   auto ConstReverseBegin() const
   {
      return m_container.ConstBegin();
   }
 
   auto ReverseEnd()
   {
      return m_container.End();
   }
 
   auto ReverseEnd() const
   {
      return m_container.End();
   }
 
   auto ConstReverseEnd() const
   {
      return m_container.ConstEnd();
   }
 
#ifndef __PCL_NO_STL_COMPATIBLE_ITERATORS
   auto begin()
   {
      return Begin();
   }
 
   auto begin() const
   {
      return Begin();
   }
 
   auto end()
   {
      return End();
   }
 
   auto end() const
   {
      return End();
   }
#endif   // !__PCL_NO_STL_COMPATIBLE_ITERATORS
 
private:
 
   container& m_container;
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif  // __PCL_Iterator_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Iterator.h - Released 2024-06-18T15:48:54Z