networkEdgePointIter.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: networkEdgePointIter.h,v $ $Revision: 1.5 $ $State: Exp $
*********************************************************************/
#ifndef networkEdgePointIter_H_
#define networkEdgePointIter_H_

//
// \file networkEdgePointIter.h
// \brief Contains the DtNetworkEdgePointIter class declaration.
//

#include "gdb/gdbDefines.h"
#include "gdb/networkEdge.h"

class DtPoint;
class DtString;

//
// DtNetworkEdgePointIter is an ABC representing
// an iterator over the points representing a DtNetworkEdge.
// \invariant At all times, this iterator must point to a valid DtNetworkEdge.
class DT_DLL_gdb DtNetworkEdgePointIter 
{
public:

   // constructor
   // \param edge The DtNetworkEdge to iterate over
   DtNetworkEdgePointIter(DtNetworkEdge& edge);

   // constructor that allows the user to specify that
   // the iterator is initialized to the end of the 
   // points of the edge.
   // \param edge The DtNetworkEdge to iterate over
   // \param isEnd Is the iterator at the end or not.
   DtNetworkEdgePointIter(DtNetworkEdge& edge, bool isEnd);

   // destructor
   virtual ~DtNetworkEdgePointIter();

   // copy constructor
   DtNetworkEdgePointIter(const DtNetworkEdgePointIter& orig);

   // assignment operator
   virtual DtNetworkEdgePointIter& operator=(const DtNetworkEdgePointIter& orig);

   // Increment/Decrement to the next/previous points.
   // \note Incrementing is defined as moving to the next point in the direction
   // in which the iterator is iterating over the edge, NOT necessarily the
   // next point in the order in which they are defined in the edge itself.
   virtual void operator++() = 0; 
   virtual void operator--() = 0; 

   // \return A reference to a const DtPoint in the edge
   virtual const DtPoint& operator*() const = 0;
   // \return A pointer to a const DtPoint in the edge
   virtual const DtPoint* operator->()  const = 0;

   // \return A boolean signifying whether the iteration is equal to the other 
   // iterator or not.
   virtual bool operator==(const DtNetworkEdgePointIter& other) const;
   virtual bool operator!=(const DtNetworkEdgePointIter& other) const;

   // \return The DtString "DtNetworkEdgePointIter"
   virtual const DtString type() const;
   
protected:
   // Tests the invariant for the class (described above)
   // \return true if the invariant is valid.
   // false otherwise.
   bool testInvariant() const;

   DtNetworkEdge* myEdge;
   bool           myIsEnd;

private:
   // default constructor
   DtNetworkEdgePointIter();
};


inline DtNetworkEdgePointIter::DtNetworkEdgePointIter(DtNetworkEdge& edge):
myEdge(&edge),
myIsEnd(false)
{
}

inline DtNetworkEdgePointIter::DtNetworkEdgePointIter(DtNetworkEdge& edge, bool isEnd):
myEdge(&edge),
myIsEnd(isEnd)
{
}


inline DtNetworkEdgePointIter::~DtNetworkEdgePointIter()
{
}

inline DtNetworkEdgePointIter::DtNetworkEdgePointIter(const DtNetworkEdgePointIter& orig)
{
   myEdge = orig.myEdge;
   myIsEnd = orig.myIsEnd;
}

inline DtNetworkEdgePointIter& DtNetworkEdgePointIter::operator=(const DtNetworkEdgePointIter& orig)
{
   if (*this != orig)
   {
      myEdge = orig.myEdge;
      myIsEnd = orig.myIsEnd;
   }

   return *this;
}

inline const DtString DtNetworkEdgePointIter::type() const
{
   return "DtNetworkEdgePointIter";
}


#endif