Decorator [Design Pattern] - Printable Version

Hi, have you ever heard about the decorator design pattern? If not, just read this topic, and hopefully you'll learn the basic concept of this powerful abstract idea.

The basic concept

In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class.
The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern.

source: wikipedia.org

Practical example

Basically the decorator pattern allows us to compose the object from multiple classes which inherits from the Decorator class. Let's just say, that we want to create a simple class called Pizza. We also want to make more types of pizza, to do that we could use the inheritance.

Squirrel Script
class Pizza
{	
	function getDescription()
	{
		return "Thin Dough"
	}
 
	function getCost()
	{
		return 4.0
	}
}
 
class MozzarellaPizza extends Pizza
{
	function getDescription()
	{
		return base.getDescription() + ", Mozzarella"
	}
 
	function getCost()
	{
		return 4.5
	}
}
 
class MozzarellaPizzaWithTomatoSouce extends MozzarellaPizza
{
	function getDescription()
	{
		return base.getDescription() + ", Tomato Souce"
	}
 
	function getCost()
	{
		return base.getCost() + 0.5
	}
}

This silly example demonstrates the basic problem, if we use the inheritance, we will end up with many types of classes, and we can't easilly combine our own pizza object from the ingredients.
So, instead of making multiple class inheritance, we will try to use the Decorator pattern in practice. The pattern requires from us to implement the class called Decorator which will be holding a reference to the pizza object, or any object,
we will make this class to be universal, that means that it could be used in different scenarios, not only pizza example.

Squirrel Script
class Decorator
{
	// making a object reference, this is needed by the pattern itself
	obj = null
 
	constructor(obj)
	{
		// assigning the passed object reference to the field
		this.obj = obj
	}
 
	// this is a _get metamethod which gets called when we try to access the field/method which doesn't exists
	// using it, we can return a field/method from the object reference
	// that's why we needed the reference
	function _get(idx)
	{
		// if object doesn't contain the specified index -> throw an error
		if (!(idx in obj))
			throw null
 
		// else -> return the content of the obj[idx]
		return obj[idx]
	}
 
	// this is a _set metamethod, it works almost the same as _get, but it get's called 
	// when we try to assigning something to a field/method which doesn't exists
	// this can be useful when we would like to change the field of the ingredient class directly
	function _set(idx, value)
	{
		// if object doesn't contain the specified index -> throw an error
		if (!(idx in obj))
			throw null
 
		// else -> assign the value to the obj[idx]
		obj[idx] = value
	}
}
 
class Pizza
{	
	function getDescription()
	{
		return "Thin Dough"
	}
 
	function getCost()
	{
		return 4.0
	}
}
 
class Mozzarella extends Decorator
{
	constructor(obj)
	{
		// calling the Decorator constructor
		base.constructor(obj)
	}
 
	function getDescription()
	{
		return obj.getDescription() + ", Mozzarella"
	}
 
	function getCost()
	{
		return obj.getCost() + 0.4
	}
}
 
class TomatoSouce extends Decorator
{
	constructor(obj)
	{
		// calling the Decorator constructor
		base.constructor(obj)
	}
 
	function getDescription()
	{
		return obj.getDescription() + ", Tomato Souce"
	}
 
	function getCost()
	{
		return obj.getCost() + 0.5
	}
}
 
addEventHandler("onInit", function()
{
	local pizza = TomatoSouce(Mozzarella(Pizza))
 
	print(pizza.getDescription()) // outputs: Thin Dough, Mozzarella, Tomato Souce
	print(pizza.getCost()) // outputs: 4.9
})

As you can see, the idea behind the pattern is really simple. The Decorator class holds a reference to the object, using this we can make multiple classes which will inherit from the Decorator and then make the object from the specified classes.
This gives you a lot more flexibility, because you can compose the object from many classes that inherits from the Decorator. In case of usage in G2O, think about the NPC AI written with the usage of this pattern, you could compose the AI from small classes which would implement only partial functionallity.

The code is based on this video: