Iterator.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.1.19
// ----------------------------------------------------------------------------
// pcl/Iterator.h - Released 2019-11-07T10:59:34Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2019 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 (http://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
{
   typedef C iterator_class;  
   typedef T item_type;       
};

// ----------------------------------------------------------------------------

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>
{
   typedef ReverseIteratorBase<BI,BidirectionalIterator,T>  __R__;
   typedef ReverseBidirectionalIterator                     __I__;

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>
{
   typedef ReverseIteratorBase<RI,RandomAccessIterator,T>   __R__;
   typedef ReverseRandomAccessIterator                      __I__;

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:

   typedef C   container;

   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 2019-11-07T10:59:34Z