eng::Visitor Class Reference

/// In parallel to the set of node classes, the Visitor class has
/// a set of Visit() methods which correlate to each class of node.
/// Each node class has an Accept(Visitor&) method.
/// A function to traverse the Graph passes the Visitor
/// to every node's Accept() method.  In turn, every node
/// calls and passes itself to the Visitor's Visit() method
/// that corresponds to the node's class.
/// The Visitor design pattern doesn't necessarily require
/// tediously defining a Visitor::Visit() method for every Node class
/// If specific action is needed for a specific Node class,
/// then Visitor::Visit(Node&) can be the default method.
///
/// Visit() will be called by Accept() of the corresponding Node class.
/// By default, each Visit is a NOP (not abstract), to facilitate
/// deriving a Visitor that only has a special action for a specific Node class.
/// NullNode::Visit() was omitted since it should never be visited.
///
/// [generalized]
///
/// class Node
/// {
///     virtual void  Accept( Visitor& visitor ) = 0;
/// };
///
/// class TransformNode : public Node
/// {
///     void  Accept( Visitor& visitor ) { visitor.Visit( *this ); }
/// };
///
/// class NodeVisitor
/// {
///     virtual void Visit( TransformNode& node ) { }
///     virtual void Visit( TextureNode& node) { }
///     [..]
/// };
///
/// void Graph::Traverse( Visitor& visitor )
/// {
///     NodeIterator nodeIter;
///     for ( nodeIter = mNodes.begin(); nodeIter != mNodes.end(); ++nodeIter )
///     {
///         nodeIter->Accept( visitor );
///         if ( not visitor ) break;  // Visitor can stop traversal
///     }
/// }
///
/// Visitors that retain a reference to a Node:
/// --------------------------------------------
/// A Visitor that retains a reference to a Node after traversal
/// should use the reference-counted Node::Ptr or risk dangling.
/// Although Visitor::Visit(Node&) isn't passed a Node::Ptr,
/// Node is a Shared object which can be converted to a Node::Ptr
/// by assigning its raw pointer to a Node::Ptr variable
/// (which is how every Node::Ptr was created).
///
/// class VisitorSearch
/// {
///     void Visit( Node& node )
///     {
///         if ( node == sought ) mMatch = &node;
///     }
/// private:
///     Node::Ptr    mMatch;
/// };
///
/// Visitor derivatives that visit node derivatives:
/// ------------------------------------------------
/// The trick is to use static_cast to cast the base Visitor to the derived Visitor,
/// in order for the compiler to select the derived Visit() method over the base one.
///
/// class Visitor
/// {
///    class SpecialNode
///    {
///    };
/// };
///
/// class VisitorDerived : public Visitor
/// {
///    class DerivedSpecialNode : public SpecialNode
///    {
///        void Accept( Visitor& visitor )
///        {
///            static_cast<DerivedVisitor&>(visitor).Visit( *this );
///            ^^^^^^^^^^^ solution
///        };
///    };
/// };
///
///


Public Member Functions
	Visitor (Graph &graph, Node::Ptr root)
	Visitor (Graph &graph)
virtual	~Visitor ()
virtual void	Visit (Node &node)
virtual void	Visit (LodNode &node)
virtual void	Visit (PartitionNode &node)
virtual void	Visit (TransformNode &node)
virtual void	Visit (VertexsNode &node)
virtual void	Visit (NormalsNode &node)
virtual void	Visit (ModesNode &node)
virtual void	Visit (MaterialNode &node)
virtual void	Visit (TextureNode &node)
virtual void	Visit (ColorsNode &node)
virtual void	Visit (PolygonNode &node)
virtual void	Visit (PolygonNode_TriColor1 &node)
virtual void	Visit (PolygonNode_TriColor3 &node)
virtual void	Visit (PolygonNode_QuadColor1 &node)
virtual void	Visit (PolygonNode_QuadColor4 &node)
virtual void	Visit (PolygonNode_Tex &node)
virtual void	Visit (PolygonNode_TexTriColor1 &node)
virtual void	Visit (PolygonNode_TexTriColor3 &node)
virtual void	Visit (PolygonNode_TexQuadColor1 &node)
virtual void	Visit (PolygonNode_TexQuadColor4 &node)
virtual void	Visit (SpecialNode &node)
Node::Ptr	GetRootNode (void) const
virtual	operator bool () const
	Can stop Graph::Traverse() by becoming false.
void	Stop (void)
virtual void	Begin (GraphTraversal::Ptr traversal)
	allows Visitor::Visit() to push "departure nodes" during traversal
virtual void	End (void)
	Visitor::End() is called after traversal ended.
Protected Member Functions
void	SetRootNode (Node::Ptr root)
Protected Attributes
Graph &	mGraph
Node::Ptr	mRoot
bool	mStop

eng::Visitor::Visitor	(	Graph &	graph,
		Node::Ptr	root
	)

eng::Visitor Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

	graph
	root	Allows traversing a partition of a Graph. Defaults to root of Graph.