mi32/vectiter.h

Go to the documentation of this file.

/**
 * \file vectiter.h <mi32/vectiter.h>
 * \brief Defintions for VECTOR_..._ITERATOR classes
 *
 * \if NODOC
 * $Id: vectiter.h_v 1.8 2005/01/14 21:37:58 mju Exp $
 *
 * $Log: vectiter.h_v $
 * Revision 1.8  2005/01/14 21:37:58  mju
 * Add cast to get rid of warning.
 *
 * Revision 1.7  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.6  2002/02/08 23:04:14  scowan
 * Changed to use vector class.
 *
 * Revision 1.5  2002/01/23 22:26:42  scowan
 * Added label iterator.
 *
 * Revision 1.4  2000/09/20 21:47:55  mju
 * In op++ check for index past end before accessing item.
 *
 * Revision 1.3  2000/07/10 19:34:27  mju
 * Now uses SpatialTree if available.
 *
 * Revision 1.2  2000/06/20 14:34:54  mju
 * Fix BITARRAY_ITERATOR.
 *
 * Revision 1.1  2000/06/08 13:21:29  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_VECTITER_H
#define  INC_MI32_VECTITER_H

#ifndef  INC_RVC_VECTOR_H
#include <rvc/vector.h>
#endif

#ifndef  INC_MI32_ELEMTYPE_H
#include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef  INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif


class BITARRAY_ITERATOR {
public:

   BITARRAY_ITERATOR (
      const UINT8* bitarray,           //!< Bit array to iterate through
      INT32 numitems,                  //!< Number of items (not bytes) in bit array
      bool testval                     //!< Value to test for
      ):
      m_bitarray(bitarray),
      m_testbit(testval?1:0),
      m_skipbyte(testval?0:255)
      {
      SetNumItems(numitems);
      Reset();
      }

   BITARRAY_ITERATOR& operator++ (
      ) {
      ++m_curitem;
      if (m_curitem >= m_numitems) return (*this);
      if (m_bitarray == 0) {
         if (m_testbit == 1) m_curitem = m_numitems;
         return (*this);
         }

      INT32 idx = m_curitem / 8;
      int i = (m_curitem % 8);
      if (i != 0 || m_bitarray[idx] != m_skipbyte) {
         UINT8 byte = static_cast<UINT8>(m_bitarray[idx] >> i);
         for (; (i < 8); ++i) {
            if ((byte & 1) == m_testbit) return (*this);
            ++m_curitem;
            byte >>= 1;
            }
         }
      for (++idx; (idx < m_maxindex && m_bitarray[idx] == m_skipbyte); ++idx) ;
      m_curitem = idx * 8;
      if (idx < m_maxindex) {
         UINT8 byte = m_bitarray[idx];
         for (i = 0; (i < 8); ++i) {
            if ((byte & 1) == m_testbit) {
               m_curitem += i;
               break;
               }
            byte >>= 1;
            }
         }
      return (*this);
      }

   //! Dereference operator - returns current item.
   INT32 operator* (
      ) const {
      return (m_curitem);
      }

   //! Cast to INT32 - returns current item.
   operator INT32 (
      ) const {
      return (m_curitem);
      }

   INT32 GetNumItems (
      ) const {
      return (m_numitems);
      }

   //! Determine if done iterating through items.
   bool IsDone (
      ) const {
      return (m_curitem >= m_numitems);
      }

   //! Reset iterator to first selected item.
   void Reset (
      ) {
      m_curitem = -1;
      operator++();
      return;
      }

   //! Set iterator to end.
   void SetDone (
      ) {
      m_curitem = m_numitems;
      return;
      }

   //! Set number of items in bit array.
   //! Does not change current iterator position.
   void SetNumItems (
      INT32 numitems
      ) {
      if (m_bitarray != 0 || m_testbit == 0) {
         m_numitems = numitems;
         m_maxindex = (numitems + 7) / 8;
         }
      else {
         //! NULL bitarray is all "false" so if want "true" then no items to iterate through
         m_numitems = -1;
         }
      return;
      }

   //! Set bit value to test for.
   //! Does not reset the iterator position.
   void SetTestValue (
      bool testval
      ) {
      m_testbit = (testval) ? 1 : 0;
      m_skipbyte = (testval) ? 0 : 255;
      return;
      }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   const UINT8* m_bitarray;
   UINT8 m_testbit;
   UINT8 m_skipbyte;
   INT32 m_maxindex;
   INT32 m_numitems;
   INT32 m_curitem;

   BITARRAY_ITERATOR (
      const BITARRAY_ITERATOR& rhs
      );
   BITARRAY_ITERATOR& operator= (
      const BITARRAY_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Base class for vector element iterators.
class VECTOR_ELEM_ITERATOR {
public:
   // CONSTRUCTION / DESTRUCTION

   #ifndef GENERATING_DOXYGEN_OUTPUT   
   class FILTER;
   #endif //!< GENERATING_DOXYGEN_OUTPUT

   explicit VECTOR_ELEM_ITERATOR (
      const RVC::VECTOR& VectorObj,
      ELEMTYPE elemtype,
      const DRECT2D* extents,
      const UINT8* bitarray,
      bool bittestval,
      FILTER* FilterFunc
      );

   virtual ~VECTOR_ELEM_ITERATOR (
      ) = 0;

   // OPERATORS

   //! Dereference operator - Returns current element.
   INT32 operator* (
      ) const {
      return (m_bititer);
      }

   //! Cast to INT32 - Returns current element.
   operator INT32 (
      ) const {
      return (m_bititer);
      }

   // METHODS

   //! Determine if at end of elements.
   bool IsDone (
      ) const {
      return (m_bititer.IsDone());
      }

   //! Set value to test for in bit array.
   void SetTestValue (
      bool testval
      ) {
      m_bititer.SetTestValue(testval);
      return;
      }

protected:
   // MEMBERS
   const RVC::VECTOR& m_VectorObj;
   ELEMTYPE m_elemtype;
   bool m_UseExtents;
   bool m_UseSpatialTree;
   DRECT2D m_Extents;
   BITARRAY_ITERATOR m_bititer;
   FILTER* m_FilterFunc;
   BITSET m_streeset;                     //!< Set of elements from SpatialTree

   // METHODS

   void CheckUseExtents (
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   // UNIMPLEMENTED
   VECTOR_ELEM_ITERATOR (
      const VECTOR_ELEM_ITERATOR& rhs
      );
   VECTOR_ELEM_ITERATOR& operator= (
      const VECTOR_ELEM_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


class VECTOR_ELEM_ITERATOR::FILTER {
   public:
      virtual int IteratorFilter (
         INT32 ElemNum
         ) = 0;
   }; 


//! Class for iterating through all points in a vector object with optional
//! use of extents rectangle and filter function.
class VECTOR_POINT_ITERATOR : public VECTOR_ELEM_ITERATOR {
public:
   // CONSTRUCTION / DESTRUCTION

   explicit VECTOR_POINT_ITERATOR (
      const RVC::VECTOR& VectorObj,
      const DRECT2D* extents = 0,
      const UINT8* bitarray = 0,
      bool bittestval = false,
      VECTOR_ELEM_ITERATOR::FILTER* FilterFunc = 0
      );

   virtual ~VECTOR_POINT_ITERATOR (
      );

   // OPERATORS

   VECTOR_POINT_ITERATOR& operator++ (
      );

   // METHODS

   //! Get current element header if available.
   //! The header is only available if it is needed by the iterator.  This typically
   //! occurs if the extents rectangle does not contain the entire vector object extents.
   //! In this case it can be significantly more efficient to use the available header
   //! rather than reading it from the file again.
   //!
   //! @return Current element header or NULL if not available.
   const RVCVECTPOINT* GetElemInfo (
      ) const {
      return (m_ElemInfoPtr);
      }

   //! Reset to first element.
   void Reset (
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   // MEMBERS
   RVCVECTPOINT m_ElemInfo;
   RVCVECTPOINT *m_ElemInfoPtr;

   // METHODS

   bool TestCurrent ();

   // UNIMPLEMENTED
   VECTOR_POINT_ITERATOR (
      const VECTOR_POINT_ITERATOR& rhs
      );
   VECTOR_POINT_ITERATOR& operator= (
      const VECTOR_POINT_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class for iterating through all nodes in a vector object with optional
//! use of extents rectangle and filter function.
class VECTOR_NODE_ITERATOR : public VECTOR_ELEM_ITERATOR {
public:
   // CONSTRUCTION / DESTRUCTION

   explicit VECTOR_NODE_ITERATOR (
      const RVC::VECTOR& VectorObj,
      const DRECT2D* extents = 0,
      const UINT8* bitarray = 0,
      bool bittestval = false,
      VECTOR_ELEM_ITERATOR::FILTER* FilterFunc = 0
      );

   virtual ~VECTOR_NODE_ITERATOR (
      );

   // OPERATORS

   VECTOR_NODE_ITERATOR& operator++ (
      );

   // METHODS

   //! Get current element header if available.
   //! The header is only available if it is needed by the iterator.  This typically
   //! occurs if the extents rectangle does not contain the entire vector object extents.
   //! In this case it can be significantly more efficient to use the available header
   //! rather than reading it from the file again.
   //!
   //! @return Current element header or NULL if not available.
   const RVCVECTNODE* GetElemInfo (
      ) const {
      return (m_ElemInfoPtr);
      }

   //! Reset to first element.
   void Reset (
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   // MEMBERS
   RVCVECTNODE m_ElemInfo;
   RVCVECTNODE *m_ElemInfoPtr;

   // METHODS

   bool TestCurrent ();

   // UNIMPLEMENTED
   VECTOR_NODE_ITERATOR (
      const VECTOR_NODE_ITERATOR& rhs
      );
   VECTOR_NODE_ITERATOR& operator= (
      const VECTOR_NODE_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class for iterating through all lines in a vector object with optional
//! use of extents rectangle and filter function.
class VECTOR_LINE_ITERATOR : public VECTOR_ELEM_ITERATOR {
public:
   // CONSTRUCTION / DESTRUCTION

   explicit VECTOR_LINE_ITERATOR (
      const RVC::VECTOR& VectorObj,
      const DRECT2D* extents = 0,
      const UINT8* bitarray = 0,
      bool bittestval = false,
      VECTOR_ELEM_ITERATOR::FILTER* FilterFunc = 0
      );

   virtual ~VECTOR_LINE_ITERATOR (
      );

   // OPERATORS

   VECTOR_LINE_ITERATOR& operator++ (
      );

   // METHODS

   //! Get current element header if available.
   //! The header is only available if it is needed by the iterator.  This typically
   //! occurs if the extents rectangle does not contain the entire vector object extents.
   //! In this case it can be significantly more efficient to use the available header
   //! rather than reading it from the file again.
   //!
   //! @return Current element header or NULL if not available.
   const RVCVECTLINE* GetElemInfo (
      ) const {
      return (m_ElemInfoPtr);
      }

   //! Reset to first element.
   void Reset (
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   // MEMBERS
   RVCVECTLINE m_ElemInfo;
   RVCVECTLINE *m_ElemInfoPtr;

   // METHODS

   bool TestCurrent ();

   // UNIMPLEMENTED
   VECTOR_LINE_ITERATOR (
      const VECTOR_LINE_ITERATOR& rhs
      );
   VECTOR_LINE_ITERATOR& operator= (
      const VECTOR_LINE_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class for iterating through all polygons in a vector object with optional
//! use of extents rectangle and filter function.
class VECTOR_POLYGON_ITERATOR : public VECTOR_ELEM_ITERATOR {
public:
   // CONSTRUCTION / DESTRUCTION

   explicit VECTOR_POLYGON_ITERATOR (
      const RVC::VECTOR& VectorObj,
      const DRECT2D* extents = 0,
      const UINT8* bitarray = 0,
      bool bittestval = false,
      VECTOR_ELEM_ITERATOR::FILTER* FilterFunc = 0,
      bool SkipIslands = false
      );

   virtual ~VECTOR_POLYGON_ITERATOR (
      );

   // OPERATORS

   VECTOR_POLYGON_ITERATOR& operator++ (
      );

   // METHODS

   //! Get current element header if available.
   //! The header is only available if it is needed by the iterator.  This typically
   //! occurs if the extents rectangle does not contain the entire vector object extents.
   //! In this case it can be significantly more efficient to use the available header
   //! rather than reading it from the file again.
   //!
   //! @return Current element header or NULL if not available.
   const RVCVECTPOLY* GetElemInfo (
      ) const {
      return (m_ElemInfoPtr);
      }

   //! Reset to first element.
   void Reset (
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   // MEMBERS
   RVCVECTPOLY m_ElemInfo;
   RVCVECTPOLY *m_ElemInfoPtr;
   bool m_SkipIslands;

   // METHODS

   bool TestCurrent ();

   // UNIMPLEMENTED
   VECTOR_POLYGON_ITERATOR (
      const VECTOR_POLYGON_ITERATOR& rhs
      );
   VECTOR_POLYGON_ITERATOR& operator= (
      const VECTOR_POLYGON_ITERATOR& rhs
      );
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class for iterating through all polygons in a vector object with optional
//! use of extents rectangle and filter function.
class VECTOR_LABEL_ITERATOR : public VECTOR_ELEM_ITERATOR {
   public:
      // CONSTRUCTION / DESTRUCTION

      explicit VECTOR_LABEL_ITERATOR (
         const RVC::VECTOR& VectorObj,
         const DRECT2D* extents = 0,
         const UINT8* bitarray = 0,
         bool bittestval = false,
         VECTOR_ELEM_ITERATOR::FILTER* FilterFunc = 0
         );

      virtual ~VECTOR_LABEL_ITERATOR (
         );

      // OPERATORS

      VECTOR_LABEL_ITERATOR& operator++ (
         );

      // METHODS

      //! Get current element header if available.
      //! The header is only available if it is needed by the iterator.  This typically
      //! occurs if the extents rectangle does not contain the entire vector object extents.
      //! In this case it can be significantly more efficient to use the available header
      //! rather than reading it from the file again.
      //!
      //! @return Current element header or NULL if not available.
      const RVC::VECTOR::LABEL* GetElemInfo (
         ) const {
         return (m_ElemInfoPtr);
         }

      //! Reset to first element.
      void Reset (
         );

   private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
      // MEMBERS
      RVC::VECTOR::LABEL m_ElemInfo;
      RVC::VECTOR::LABEL* m_ElemInfoPtr;

      // METHODS

      bool TestCurrent ();

      // UNIMPLEMENTED
      VECTOR_LABEL_ITERATOR (const VECTOR_LABEL_ITERATOR& rhs);
      VECTOR_LABEL_ITERATOR& operator= (const VECTOR_LABEL_ITERATOR& rhs);
   #endif // GENERATING_DOXYGEN_OUTPUT
   };


#endif   //!< INC_MI32_VECTITER_H

---