networkEdgeSegmentConstIter.h

Go to the documentation of this file.

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

//
// \file networkEdgeSegmentConstIter.h
// \brief Contains the DtNetworkEdgeSegmentConstIter class declaration.
//

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

class DtSegment;
class DtString;


//
// DtNetworkEdgeSegmentConstIter is an ABC representing
// a const iterator over the segments of a DtNetworkEdge.
// \invariant At all times, this iterator must point to a valid DtNetworkEdge.
// \invariant This iterator cannot be used to modify the reference DtNetworkEdge.
class DT_DLL_gdb DtNetworkEdgeSegmentConstIter 
{
public:
   // \param an edge to iterate over.
   DtNetworkEdgeSegmentConstIter(const DtNetworkEdge& edge);

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

   // destructor
   virtual ~DtNetworkEdgeSegmentConstIter();

   // \return A DtPoint representing the starting or ending point of 
   // the segment as defined in the direction of iteration.
   virtual DtPoint startPoint() const = 0;
   virtual DtPoint endPoint() const = 0;

   virtual const DtNetworkEdge& edge() const;

   // Increments/Decrements to the next/previous segment in the edge as defined
   // by the direction of iteration.
   virtual void operator++() = 0; 
   virtual void operator--() = 0; 
   virtual const DtNetworkSegment& operator*() const = 0;
   virtual const DtNetworkSegment& operator->()  const = 0;

   virtual bool operator==(const DtNetworkEdgeSegmentConstIter& other) const;
   virtual bool operator!=(const DtNetworkEdgeSegmentConstIter& other) const;

   // \return the DtString "DtNetworkEdgeSegmentConstIter"
   virtual const DtString type() const;
   
protected:
   // Tests the invariant of the iterator as defined above.
   // \return a boolean signifying true if the invariant is valid
   // and false otherwise.
   bool testInvariant() const;

   // default constructor
   DtNetworkEdgeSegmentConstIter();

   const DtNetworkEdge* myEdge;
};


inline DtNetworkEdgeSegmentConstIter::DtNetworkEdgeSegmentConstIter(const DtNetworkEdge& edge):
myEdge(&edge)
{
   assert(testInvariant());
}

inline DtNetworkEdgeSegmentConstIter::~DtNetworkEdgeSegmentConstIter()
{
}

inline DtNetworkEdgeSegmentConstIter::DtNetworkEdgeSegmentConstIter(const DtNetworkEdgeSegmentConstIter& orig)
{
   assert(testInvariant());

   myEdge = orig.myEdge;
   
   assert(testInvariant());
}

inline const DtString DtNetworkEdgeSegmentConstIter::type() const
{
   assert(testInvariant());

   return "DtNetworkEdgeSegmentConstIter";
}


#endif