Single-serving visitor pattern


In computer programming, the single-serving visitor pattern is a design pattern. Its intent is to optimise the implementation of a visitor that is allocated, used only once, and then deleted.

Applicability

The single-serving visitor pattern should be used when visitors do not need to remain in memory. This is often the case when visiting a hierarchy of objects to perform a single task on it, for example counting the number of cameras in a 3D scene.
The regular visitor pattern should be used when the visitor must remain in memory. This occurs when the visitor is configured with a number of parameters that must be kept in memory for a later use of the visitor.
However, if there should be only one instance of such a visitor in a whole program, it can be a good idea to implement it both as a single-serving visitor and as a singleton. In doing so, it is ensured that the single-serving visitor can be called later with its parameters unchanged.

Usage examples

The single-serving visitor is called through the intermediate of static methods.
  • Without parameters:
Element* elem;
SingleServingVisitor::apply_to;

  • With parameters:
Element* elem;
TYPE param1, param2;
SingleServingVisitor::apply_to;

Element* elem;
TYPE param1, param2;
SingleServingVisitor::set_param1;
SingleServingVisitor::set_param2;
SingleServingVisitor::apply_to;

Consequences

Pros

No "zombie" objects. With a single-serving visitor, it is ensured that visitors are allocated when needed and destroyed once useless.A simpler interface than visitor. The visitor is created, used and free by the sole call of the apply_to static method.

Cons

Repeated allocation. At each call of the apply_to method, a single-serving visitor is created then discarded, which is time-consuming. In contrast, the singleton only performs one allocation.

Implementation (in C++)

Basic implementation (without parameters)


// Declaration
class Element;
class ElementA;
class ElementB;
class SingleServingVisitor;
... // Same as with the visitor pattern.
// Definition
class SingleServingVisitor
// Implementation
void SingleServingVisitor::apply_to

Passing parameters

If the single-serving visitor has to be initialised, the parameters have to be passed through the static method:

void SingleServingVisitor::apply_to

Implementation as a singleton

This implementation ensures:
  • that there is at most one instance of the single-serving visitor
  • that the visitor can be accessed later

// Definition
class SingleServingVisitor
// Implementation
SingleServingVisitor* SingleServingVisitor::instance_ = NULL;
SingleServingVisitor* SingleServingVisitor::get_instance
void SingleServingVisitor::apply_to
void SingleServingVisitor::set_param1
void SingleServingVisitor::set_param2

Related patterns