networkEdgePointConstIter.h

Go to the documentation of this file.

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

//
// \file networkEdgePointConstIter.h
// \brief Contains the DtNetworkEdgePointConstIter class declaration.
//

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

class DtPoint;
class DtString;

//
// DtNetworkEdgePointConstIter is an ABC representing
// a const iterator over the points representing a DtNetworkEdge.
// \invariant At all times, this iterator must point to a valid DtNetworkEdge.
// \invariant This iterator can not be used to modify the referenced DtNetworkEdge
class DT_DLL_gdb DtNetworkEdgePointConstIter 
{
public:

   // constructor
   // \param edge The DtNetworkEdge to iterate over
   DtNetworkEdgePointConstIter(const 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.
   DtNetworkEdgePointConstIter(const DtNetworkEdge& edge, bool isEnd);

   // destructor
   virtual ~DtNetworkEdgePointConstIter();

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

   // assignment operator
   virtual DtNetworkEdgePointConstIter& operator=(const DtNetworkEdgePointConstIter& 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 DtNetworkEdgePointConstIter& other) const;
   virtual bool operator!=(const DtNetworkEdgePointConstIter& other) const;

   // \return the DtString "DtNetworkEdgePointConstIter"
   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;

   const DtNetworkEdge* myEdge;
   bool                 myIsEnd;

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


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

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


inline DtNetworkEdgePointConstIter::~DtNetworkEdgePointConstIter()
{
}

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

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

   return *this;
}

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


#endif