Посетитель - паттерн поведения объектов, задающий стратегии обхода. оригинал codelab.ru источник codelab.ru

Условия, Задача, Назначение

Позволяет определить и задать на выполнение новую операцию, не изменяя ни классы этих объектов, ни их структуры. оригинал codelab.ru источник codelab.ru

codelab.ru оригинал codelab.ru источник

источник codelab.ru codelab.ru оригинал

оригинал codelab.ru codelab.ru источник

1. В структуре присутствуют объекты многих классов
   С различными интерфейсами и вы хотите выполнять над ними операции, зависящие от конкретных классов. codelab.ru codelab.ru оригинал источник
2. Над объектами, входящими в состав структуры, надо выполнять разнообразные, не связанные между собой операции и вы не хотите «засорять» классы такими операциями. Посетитель позволяет объединить родственные операции, поместив их в один класс. Если структура объектов является общей для нескольких приложений, то паттерн посетитель позволит в каждое приложение включить только относящиеся к нему операции. codelab.ru codelab.ru оригинал источник
3. Классы, устанавливающие структуру объектов, изменяются редко, но новые операции над этой структурой добавляются часто.
   При изменении классов, представленных в структуре, нужно будет переопределить интерфейсы всех посетителей, а это может вызвать затруднения. Поэтому если классы меняются достаточно часто, то, вероятно, лучше определить операции прямо в них. оригинал codelab.ru источник codelab.ru

Решение

источник codelab.ru оригинал codelab.ru

Участники паттерна Посетитель (Visitor)

1. Visitor (NodeVisitor) – посетитель.
   Объявляет операцию VisitXXX для каждого класса ConcreteElement в структуре объектов. Имя и сигнатура этой операции идентифицируют класс, который посылает посетителю запрос Visit-а. Имя метода позволяет посетителю определить, элемент какого конкретного класса он посещает, а ссылка на этот элемент передающая при вызове – обращаться к нему через его интерфейс. источник codelab.ru codelab.ru оригинал
2. ConcreteVisitor (TypeCheckingVisitor) - конкретный посетитель.
   Реализует все операции, объявленные в классе Visitor. Каждая операция реализует фрагмент алгоритма, определенного только для класса соответствующего объекта в структуре. Класс ConcreteVisitor предоставляет контекст для этого алгоритма и сохраняет его локальное состояние. Часто в этом состоянии аккумулируются результаты, полученные в процессе обхода структуры. codelab.ru оригинал codelab.ru источник
3. Element (Node) – элемент.
   Определяет операцию Accept, которая принимает посетителя в качестве аргумента. источник оригинал codelab.ru codelab.ru
4. ConcreteElement (AssignmentNode, VariableRefNode) – конкретный элемент.
   Реализует операцию Accept, принимающую посетителя как аргумент. Реализует он ее каждый раз по-разному: а именно вызывает только тот Visit-метод, который для него предназначен. оригинал codelab.ru источник codelab.ru
5. ObjectStructure (Program) - структура объектов.
   Перечисляет свои элементы.
   Предоставляет посетителю высокоуровневый интерфейс для посещения своих элементов.
   Может быть как составным объектом (см. паттерн компоновщик), так и коллекцией, например списком или множеством. источник оригинал codelab.ru codelab.ru

codelab.ru источник оригинал codelab.ru

class Visitor {
public:
  virtual void VisitElementA(ElementA*);
  virtual void VisitElementB(Elements*);
 
  // и так далее для остальных конкретных элементов
protected:
  Visitor() ;
};

class Element {
public:
  virtual ~Element();
  virtual void Accept(Visitors) = 0;
protected:
  Element();
};
 
class ElementA : public Element {
public:
  ElementA();
  virtual void Accept(Visitors v) { v.VisitElementA(this); }
};
class ElementB : public Element {
public:
  ElementB();
  virtual void Accept(Visitors v) { v.VisitElementB(this); }
};

class CompositeElement : public Element {
public:
  virtual void Accept(Visitors);
private:
  List<Element*>* _children;
};
void CompositeElement::Accept (Visitors v) {
  ListIterator<Element*> i(_children);
  for (i.First(); !i.IsDone(); i.Next() {
    i .Currentltem()->Accept(v) ;
  }
  v.VisitCompositeElement(this);
}

package visitor.ex;
 
public interface Visitor {
	void VisitElementA(ElementA el);
	void VisitElementB(ElementB el);
	void VisitCompositeElement(CompositeElement el);
}

package visitor.ex;
 
public interface Element {
	void Accept(Visitor v); 
}
 
class ElementA implements Element {
 
	public void Accept(Visitor v) {
		v.VisitElementA(this);
	}
}
 
class ElementB implements Element {
 
	public void Accept(Visitor v) {
		v.VisitElementB(this);
	}
 
}
 

package visitor.ex;
 
import java.util.Iterator;
import java.util.List;
 
public class CompositeElement implements Element {
	private List<Element> children;
 
	public void Accept(Visitor v) {
		Iterator<Element> childIter = children.iterator();
		while (childIter.hasNext()) {
			childIter.next().Accept(v);
		}
		v.VisitCompositeElement(this);
	}
 
}
 

1. Двойная диспетчеризация.
   По своей сути паттерн посетитель позволяет, не изменяя классы, добавлять в них новые операции. Достигает он этого с помощью приема, называемого двойной диспетчеризацией. Данная техника хорошо известна. Некоторые языки программирования (например, CLOS) поддерживают ее явно. Языки же вроде C++ и Smalltalk поддерживают только одинарную диспетчеризацию.
   Для определения того, какая операция будет выполнять запрос, в языках с одинарной диспетчеризацией неоходимы имя запроса и тип получателя. Например, то, какая операция будет вызвана для обработки запроса GenerateCode, зависит от типа объекта в узле, которому адресован запрос. В C++ вызов GenerateCode для экземпляра VariableRefNode приводит к вызову функции VariableRefNode::GenerateCode (генерирующей код обращения к переменной). Вызов же GenerateCode для узла класса AssignmentNode приводит к вызову функции AssignmentNode::GenerateCode (генерирующей код для оператора присваивания). Таким образом, выполняемая операция определяется одновременно видом запроса и типом получателя.
   Понятие «двойная диспетчеризация» означает, что выполняемая операция зависит от вида запроса и типов двух получателей. Accept – это операция с двойной диспетчеризацией. Ее семантика зависит от типов двух объектов: Visitor и Element. Двойная диспетчеризация позволяет посетителю запрашивать разные операции для каждого класса элемента (Если есть двойная диспетчеризация, то почему бы не быть тройной, четверной или диспетчеризации произвольной кратности? Двойная диспетчеризация - это просто частный случай множественной диспетчеризации, при которой выбираемая операция зависит от любого числа типов. CLOS как раз и поддерживает множественную диспетчеризацию.В языках с поддержкой двойной или множественной диспетчеризации необходимость в паттерне посетитель возникает гораздо реже.)
   Поэтому возникает необходимость в паттерне посетитель: выполняемая операция зависит и от типа посетителя, и от типа посещаемого элемента. Вместо статической привязки операций к интерфейсу класса Element мы можем консолидировать эти операции в классе Visitor и использовать Accept для привязки их во время выполнения. Расширение интерфейса класса Element сводится к определению нового подкласса Visitor, а не к модификации многих подклассов Element. codelab.ru codelab.ru оригинал источник
2. Какой участник несет ответственность за обход структуры.
   Посетитель должен обойти каждый элемент структуры объектов. Вопрос в том, как туда попасть. Ответственность за обход можно возложить либо на саму структуру объектов, либо на посетителя либо на отдельный объект-итератор (см. паттерн итератор).
   Чаще всего структура объектов отвечает за обход. Коллекция просто обходит все свои элементы, вызывая для каждого операцию Accept. Составной объект обычно обходит самого себя, «заставляя» операцию Accept посетить потомков текущего элемента и рекурсивно вызвать Accept для каждого из них.
   Другое решение - воспользоваться итератором для посещения элементов.
   Можно применить внутренний или внешний итератор, в зависимости от того, что доступно и более эффективно. Поскольку внутренние итераторы реализуются самой структурой объектов, то работа с ними во многом напоминает предыдущее решение, когда за обход отвечает структура.
   Основное различие заключается в том, что внутренний итератор не приводит к двойной диспетчеризации: он вызывает операцию посетителя с элементом в качестве аргумента, а не операцию элемента с посетителем в качестве аргумента. Однако использовать паттерн посетитель с внутренним итератором легко в том случае, когда операция посетителя вызывает операцию элемента без рекурсии.
   Можно даже поместить алгоритм обхода в посетитель, хотя закончится это дублированием кода обхода в каждом классе ConcreteVisitor для каждого агрегата ConcreteElement. Основная причина такого решения – необходимость реализовать особо сложную стратегию обхода, зависящую от результатов операций над объектами структуры. источник оригинал codelab.ru codelab.ru

1. Упрощает добавление новых операций.
   С помощью посетителей легко добавлять операции, зависящие от компонентов сложных объектов. Для определения новой операции над структурой объектов достаточно просто ввести нового посетителя. Напротив, если функциональность распределена по нескольким классам, то для определения новой операции придется изменить каждый класс. codelab.ru оригинал codelab.ru источник
2. Объединяет родственные операции и отсекает те, которые не имеют к ним отношения.
   Родственное поведение не разносится по всем классам, присутствующим в структуре объектов, оно локализовано в посетителе. Не связанные друг с другом функции распределяются по отдельным подклассам класса Visitor. Это способствует упрощению как классов, определяющих элементы, так и алгоритмов, инкапсулированных в посетителях. Все относящиеся к алгоритму структуры данных можно скрыть в посетителе. codelab.ru источник оригинал codelab.ru
3. Добавление новых классов ConcreteElement затруднено.
   Паттерн посетитель усложняет добавление новых подклассов класса Element. Каждый новый конкретный элемент требует объявления новой абстрактной операции в классе Visitor, которую нужно реализовать в каждом из существующих на данный момент классов ConcreteVisitor. Иногда большинство конкретных посетителей могут унаследовать операцию по умолчанию, предоставляемую классом Visitor, но это, скорее, исключение, чем правило.
   Поэтому при решении вопроса о том, стоит ли использовать паттерн посетитель, нужно прежде всего посмотреть, что будет изменяться чаще: алгоритм, применяемый к объектам структуры, или классы объектов, составляющих эту структуру. Вполне вероятно, что сопровождать иерархию классов Visitor будет нелегко, если новые классы ConcreteElement добавляются часто. В таких случаях проще определить операции прямо в классах, представленных в структуре. Если же иерархия классов Element стабильна, но постоянно расширяется набор операций или модифицируются алгоритмы, то паттерн посетитель поможет лучше управлять такими изменениями. источник codelab.ru codelab.ru оригинал
4. Посещение различных иерархий классов.
   Итератор может посещать объекты структуры по мере ее обхода, вызывая операции объектов. Но итератор не способен работать со структурами, состоящими из объектов разных типов. Так, интерфейс класса Iterator, может всего лишь получить доступ к объектам типа Item:
   
    итератор для доступа к элементам [C++]  ссылка
   

   template <class Item>
   class Iterator {
     // ...
     Item CurrentltemO const;
   };

   template <class Item> class Iterator { // ... Item CurrentltemO const; };
   Отсюда следует, что все элементы, которые итератор может посетить, должны иметь общий родительский класс Item.
   У посетителя таких ограничений нет. Ему разрешено посещать объекты, не имеющие общего родительского класса. В интерфейс класса Visitor можно добавить операции для объектов любого типа. Например, в следующем объявлении:
    наличие операций любого типа [C++]  ссылка
   

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

   class Visitor { public: // ... void VisitMyType(MyType*); void VisitYourType(YourType*); };
   классы МуТуре и YourType необязательно должны быть связаны отношением наследования. источник оригинал codelab.ru codelab.ru
5. Аккумулирование состояния.
   Посетители могут аккумулировать информацию о состоянии при посещении объектов структуры. Если не использовать этот паттерн, состояние придется передавать в виде дополнительных аргументов операций, выполняющих обход, или хранить в глобальных переменных. codelab.ru источник codelab.ru оригинал
6. Нарушение инкапсуляции.
   Применение посетителей подразумевает, что у класса ConcreteElement достаточно развитый интерфейс для того, чтобы посетители могли справиться со своей работой. Поэтому при использовании данного паттерна приходится предоставлять много открытых операций для доступа к внутреннему состоянию элементов, что ставит под угрозу инкапсуляцию. codelab.ru оригинал источник codelab.ru

Для поддержки посетителя в класс Equipment добавляется операция Accept: Equipment. codelab.ru источник оригинал codelab.ru

Марк Линтон (Mark Linton) ввел термин «посетитель» (Visitor) в спецификацию библиотеки для построения приложений X Consortium's Fresco Application Toolkit. codelab.ru оригинал источник codelab.ru

Интерпретатор: посетитель может использоваться для выполнения интерпретации. codelab.ru codelab.ru источник оригинал