1. Visitor ¶

• Visitor (NodeVisitor)
  
  - declares a Visit operations for each class of ConcreteElement in the object structure. The operation's name and signature identifies the class that sends the Visit request to the visitor. That lets the visitor determine the concrete class of the element being visited. Then the visitor can access the element directly through its particular interface.
  
• ConcreteVisitor (TypeCheckingVisitor)
  
  - implements each operation declared by Visitor. Each operation implements a fragment of the algorithm defined for the corresponding class of object in the structure. ConcreteVisitor provides the context for the algorithm and stores its local state. This state often accumulates result during the traversal of the structure.
  
• Element (Node)
  
  - defines an Accept operation that takes a visitor as an argument.
  
• ConcreteElement (AssignmentNode, VariableRefNode)
  
  - implements an Accept operation that takes a visitor as an argument.
  
• ObjectStructure (Program)
  
  - can enumerate its elements.
  
  - may provide a high-level interface to allow the visitor to visit its elements.
  
  - may either be a composite (See CompositePattern) or a collection such as a list or a set.
  
  
  

class Visitor {
public:
	// ...
	void VisitMyType (MyType*);
	void VisitYourType (YourType*);
};

class Element {
public:
	virtual ~Element ();
	virtual void Accept (Visitor&) = 0;
protected:
	Element ();
};

class ElementA : public Element {
public:
	ElementA ();
	virtual void Accept (Visitor& v) { v.VisitElementA (this); }
};

class ElementB : public Element {
public:
	ElementB ();
	virtual void Accept (Visitor& v) { v.VisitElementB (this); }
};

class CompositeElement : public Element {
public:
	virtual void Accept (Visitor&);
private:
	List<Element*>* _children;
};

void CompositeElement::Accept (Visitor& v) {
	ListIterator<Element*> i (_children);

	for (i.First (); !i.IsDone(); i.Next ()) {
		i.CurrentItem ()->Accept (v);
	}
	v.VisitCompositeElement (this);
}

class EquipmentVisitor {
public:
	virtual ~EquipmentVisitor ();

	virtual void VisitFloppyDisk (FloppyDisk*);
	virtual void VisitCard (Card*);
	virtual void VisitrChassis (Chassis*);
	virtual void VisitBus (Bus*);

	// and so on for other concrete subclasses of Equipment
protected:
	EquipmentVisitor ();
};

void FloppyDisk::Accept (EquipmentVisitor& visitor) {
	visitor.VisitFloppyDisk (this);
}

void Chassis::Accept (EquipmentVisitor& visitor) {
	for (ListIterator<Equipment*> i(_parts); !i.IsDone (); i.Next ()) {
		i.CurrentItem ()->Accept (visitor);
	}
	visitor.VisitChassis (this);
}

class PricingVisitor : public EquipmentVisitor {
public:
	PricingVisitor ();

	Currency& GetTotalPrice ();

	virtual void VisitFloppyDisk (FloppyDisk*);
	virtual void VisitCard (Card*);
	virtual void VisitChassis (Chassis*);
	virtual void VisitBus (Bus*);
	// ...
private:
	Currency _total;
};

void PricingVisitor::VisitFloppyDisk (FloppyDisk* e) {
	_total += e->NextPrice ();
}

void PricingVisitor::VisitChassis (Chassis* e) {
	_total += e->DiscountPrice ();
}

class InventoryVisitoy : public EquipmentVisitor {
public:
	InventoryVisitor ();

	Inventory& GetInventory ();

	virtual void VisitFloppyDisk (FloppyDisk*);
	virtual void VisitCard (Card*);
	virtual void VisitChassis (Chassis*);
	virtual void VisitBus (Bus*);
	// ...

private:
	Inventory _inventory;
};

void InventoryVisitor::VisitFloppyDisk (FloppyDisk* e) {
	_inventory.Accumulate (e);
}

void InventoryVisitor::VisitChassis (Chassis* e) {
	_inventory.Accumulate (e);
}

Equipment* component;
InventoryVisitor visitor;

component->Accept (visitor);
cout << "Inventory "
	<< componet->Name ()
	<< visitor.GetInventory ();

accept: aVisitor
	^ aVisitor visitSequence : self

visitSequence: sequenceExp
	inputState := sequenceExp expression1 accept: self.
	^ sequenceExp expression2 accept: self.

visitRepeat : repeatExp
	| finalState |
	finalState := inputState copy.
	[inputState isEmpty]
		whileFalse:
		[inputState := repeatExp repetition accept: self.
		finalState addAll: inputState].
	^ finalState

visitAlternation: alternateExp
	| finalState originalState |
	originalState := inputState.
	finalState := alternateExp alternative1 accept: self.
	inputState := originalState.
	finalState addAll: (alternateExp alternative2 accept: self).
	^ finalState

visitLiteral: literalExp
	| finalState tStream |
	finalState := Set new.
	inputState
		do:
			[:stream | tStream := stream copy.
				(tStream nextAvailable:
					literalExp components size
				) = literalExp components
					ifTrue: [finalState add: tStream]
			].
	^ finalState