Single-serving visitor

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 (which is the case of most visitors).

Применение

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 is used together with the composite pattern) 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 (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. 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).

Пример использования

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);

Плюси

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.

Минусы

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 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

138

// Предназначение

public abstract class SingleServingVisitor

{

protected static SingleServingVisitor instance_ = null; protected TYPE param1_ = new TYPE();

protected TYPE param2_ = new TYPE(); // Реализация

protected static SingleServingVisitor get_instance()

{

if (this.instance_ == null)

this.instance_ = new SingleServingVisitor(); return this.instance_;

}

//Примечание: метод get_instance не должен быть публичным

SingleServingVisitor();

public static void apply_to(Element elem)

{

elem.accept(get_instance());

}

//Статические методы для доступа к параметрам

public static void set_param1(TYPE param1)

{

getInstance().param1_ = param1;

}

public static void set_param2(TYPE param2)

{

getInstance().param2_ = param2;

}

public abstract void visit_ElementA(ElementA NamelessParameter);

public abstract void visit_ElementB(ElementB NamelessParameter);

}

139