networkEdgeTraverser.h

Go to the documentation of this file.

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

//
// \file networkEdgeTraverser.h
// \brief Contains the DtNetworkEdgeTraverser class declaration.
//

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

class DtNetworkNode;
class DtNetworkEdgePointIter;
class DtNetworkEdgePointConstIter;
class DtNetworkEdgeSegmentIter;
class DtNetworkEdgeSegmentConstIter;
class DtPoint;
class DtString;

//
// DtNetworkEdgeTraverser represents an object that knows how to traverse in the
// specified direction over an DtNetworkEdge.  Used for traversing the 
// vector network.
class DT_DLL_gdb DtNetworkEdgeTraverser 
{
public:

   // constructor
   DtNetworkEdgeTraverser(DtNetworkEdge& edge, 
      DtNetworkEdge::DtTraversalDirection traversalDirection);

   // destructor
   virtual ~DtNetworkEdgeTraverser();

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

   // assignment operator
   DtNetworkEdgeTraverser& operator=(const DtNetworkEdgeTraverser& orig);

   
   // \return a const reference to the traverser's edge
   DtNetworkEdge& edge();
   const DtNetworkEdge& edge() const;

   DtNetworkNode& startNode();
   DtNetworkNode& endNode();

   const DtNetworkNode& startNode() const;
   const DtNetworkNode& endNode() const;

   const DtPoint startPoint() const;
   const DtPoint endPoint() const;

   // \return an iterator, const or non-const, to the beginning or 
   // the end of the segments
   // \note - These are not necessarily forward or reverse in the traditional interator sense. 
   // It depends on the direction of traversal.  If traversing in reverse, a reverse iterator request 
   // will return a *foward* iterator.
   std::auto_ptr<DtNetworkEdgeSegmentIter> segmentsBegin();
   std::auto_ptr<DtNetworkEdgeSegmentConstIter> segmentsBegin() const;

   std::auto_ptr<DtNetworkEdgeSegmentIter> segmentsEnd();
   std::auto_ptr<DtNetworkEdgeSegmentConstIter> segmentsEnd() const;

   std::auto_ptr<DtNetworkEdgeSegmentIter> getIterForSegment(const DtNetworkSegment& segment);
   std::auto_ptr<DtNetworkEdgeSegmentConstIter> getIterForSegment(const DtNetworkSegment& segment) const;

   // \return An auto_ptr to a DtNetworkEdgeSegmentIter that can be used to iterate over the segments
   // of the edge, in the specified traversal direction.  
   std::auto_ptr<DtNetworkEdgeSegmentIter> segmentIter(const DtNetworkSegment& segment);
   std::auto_ptr<DtNetworkEdgeSegmentConstIter> segmentIter(const DtNetworkSegment& segment) const;


   // \return an iterator, const or non-const, to the beginning or 
   // the end of the points in the edge.
   // \note - These are not necessarily beginning/end or forward/reverse in the traditional interator sense. 
   // It depends on the direction of traversal.  If traversing in reverse, a reverse iterator request 
   // will return a *foward* iterator.
   std::auto_ptr<DtNetworkEdgePointIter> pointsBegin();
   std::auto_ptr<DtNetworkEdgePointConstIter> pointsBegin() const;

   std::auto_ptr<DtNetworkEdgePointIter> pointsEnd();
   std::auto_ptr<DtNetworkEdgePointConstIter> pointsEnd() const;

   // \return a point iterator initialized to the point in the edge specified.  
   // If the point is NOT in the edge, the iterator will be initialized to the
   // starting point in the appropriate direction of traversal.
   std::auto_ptr<DtNetworkEdgePointIter> pointIter(const DtPoint& pointInEdge);
   std::auto_ptr<DtNetworkEdgePointConstIter> pointIter(const DtPoint& pointInEdge) const;

   // \return the DtString "DtNetworkEdgeTraverser"
   virtual DtString type();

   virtual DtNetworkEdge::DtTraversalDirection direction() const;
   virtual void setDirection(DtNetworkEdge::DtTraversalDirection newDirection);
   
protected:
   // Tests to see if the class invariant is valid.
   // \return a boolean indicating whether or not the invariant
   // is valid.
   bool testInvariant() const;

   bool traversingForward() const;
   
   DtNetworkEdge::DtTraversalDirection myTraversalDirection;

   DtNetworkEdge* myEdge;

};


#endif