In computer programming

Computer programming

Computer programming is the process of designing, writing, testing, debugging, and maintaining the source code of computer programs. This source code is written in one or more programming languages. The purpose of programming is to create a program that performs specific operations or exhibits a...

, the single-serving visitor pattern is a design pattern

Design pattern (computer science)

In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that...

. Its intent is to optimise the implementation of a visitor

Visitor pattern

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...

 that is allocated, used only once, and then deleted (which is the case of most visitors).

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 (such as when the visitor pattern

Visitor pattern

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...

 is used together with the composite pattern

Composite pattern

In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent...

) to perform a single task on it, for example counting the number of cameras in a 3D scene.

The regular visitor pattern

Visitor pattern

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...

 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 (for example, for storing the rendering options of a 3D scene renderer).

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

Singleton pattern

In software engineering, the singleton pattern is a design pattern used to implement the mathematical concept of a singleton, by restricting the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system...

. In doing so, it is ensured that the single-serving visitor can be called later with its parameters unchanged (in this particular case "single-serving visitor" is an abuse of language since the visitor can be used several times).

Usage examples

The single-serving visitor is called through the intermediate of static methods.

• Without parameters:

Element* elem;
SingleServingVisitor::apply_to(elem);

• With parameters:

Element* elem;
TYPE param1, param2;
SingleServingVisitor::apply_to(elem, param1, param2);

• Implementation as a singleton:

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

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.

Basic implementation (without parameters)

// Declaration
class Element;
class ElementA;
class ElementB;
class SingleServingVisitor;

... // Same as with the visitor pattern

Visitor pattern

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...

.

// Definition
class SingleServingVisitor {
protected:
SingleServingVisitor;
public:
~SingleServingVisitor;

static void apply_to(Element*);
virtual void visit_ElementA(ElementA*) = 0;
virtual void visit_ElementB(ElementB*) = 0;
}

// Implementation
void SingleServingVisitor::apply_to(Element* elem)
{
SingleServingVisitor ssv;
elem.accept(ssv);
}

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(Element* elem, TYPE param1, TYPE param2, ...)
{
SingleServingVisitor ssv(param1, param2, ...);
elem.accept(&ssv);
}

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 {
protected:
static SingleServingVisitor* instance_;
TYPE param1_;
TYPE param2_;

SingleServingVisitor;

static SingleServingVisitor* get_instance;
// Note: get_instance method does not need to be public

public:
~SingleServingVisitor;

static void apply_to(Element*);

// static methods to access parameters
static void set_param1(TYPE);
static void set_param2(TYPE);

virtual void visit_ElementA(ElementA*) = 0;
virtual void visit_ElementB(ElementB*) = 0;
}

// Implementation
SingleServingVisitor* SingleServingVisitor::instance_ = NULL;

SingleServingVisitor* SingleServingVisitor::get_instance
{
if (this->instance_ NULL)
this->instance_ = new SingleServingVisitor;
return this->instance_;
}

void SingleServingVisitor::apply_to(Element* elem)
{
elem->accept(get_instance);
}

void SingleServingVisitor::set_param1(TYPE param1)
{
getInstance->param1_ = param1;
}

void SingleServingVisitor::set_param2(TYPE param2)
{
getInstance->param2_ = param2;
}

Related patterns

• Visitor pattern
  Visitor pattern
  In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those...
  
  , from which this pattern derives
• Composite pattern
  Composite pattern
  In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes that a group of objects are to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent...
  
  : single-serving visitor is often applied to hierarchies of elements
• Singleton pattern
  Singleton pattern
  In software engineering, the singleton pattern is a design pattern used to implement the mathematical concept of a singleton, by restricting the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system...