Patrón Compuesto - ActionScript 3.0

Patrón Compuesto

Después de varios meses de inactividad en el blog xD (prometo no dejarlo abandonado de nuez), vamos a ver un tema muy interesante, el patrón compuesto implementado en ActionScript 3.0.

Este patrón tiene la finalidad de resolver la complejidad que podría resultar al hacer estructuras parecidas a la de un árbol de objetos, tanto la creación de estructuras complejas como la navegación sobre ellas se podrá hacer de forma sencilla implementándolo.

Imaginémonos el árbol del tule (por si no lo saben está en Oaxaca, es el árbol más gordo del mundo hahahahaha), pues el tule está formado por ramas y hojas, por ejemplo las ramas pueden tener otras ramas y otras hojas y así sucesivamente.

Nuestra rama es una composición de uno o más objetos similares que tiene una funcionalidad similar y también tenemos a las hojas que son objetos únicos, no tienen otros objetos dentro de ellas como las ramas.

Un ejemplo:

La clave está en implementar la misma interfaz tanto para los objetos compuestos (ramas) como las hojas (objetos únicos), todo esto hace que programemos por interfaz sin importar que tipo de objetos estemos utilizando a nuestra clase gestora de ramas y hojas (Árbol del Tule) no le importa que tipo concreto le demos, a esta solo le importa que le demos instancias de clase que implementen la interfaz.

Veamos como haríamos nuestro diagrama implementando el patrón:

Como podemos ver tanto nuestras clases Hoja y Rama implementan la interfaz ITreeElement y la Rama a su vez puede contener más instancias de clase que implemente la interfaz ITreeElement. La clase Árbol es la que va a ser utilizada por el cliente para formar la estructura del Tule (si que le va a costar trabajo), agregando ramas o hojas.

Ahora si empecemos a codificar el diagrama, empecemos por la interfaz:

1   package {
2   
3       public interface ITreeElement {
4           function addElement(element:ITreeElement):void;
5           function removeElement(element:ITreeElement):Boolean;
6           function getInfo():String;
7       }
8   }

Ahora las 2 clases concretas (Rama y Hoja) que implementarán la interfaz ITreeElement:

1   package {
2   
3       import mx.collections.ArrayCollection;
4   
5       public class Rama implements ITreeElement {
6       
7       
8           private var _elementos:ArrayCollection;
9       
10       
11           public function Rama() {
12               _elementos = new ArrayCollection();
13           }
14       
15           public function addElement(element:ITreeElement):void {
16               _elementos.addItem(element);
17           }
18       
19           public function removeElement(element:ITreeElement):Boolean {
20               for(var i:Number = 0; i < _elementos.length; i++) {
21                   if(_elementos.getItemAt(i) == element) {
22                       _elementos.removeItemAt(i);
23                       return true;
24                   }
25               }
26               return false;
27           }
28       
29           public function getInfo():String {
30               var output:String = "\n--------------------------------------\n";
31               output += "Soy una rama y tengo "+_elementos.length+" elemento(s) : ";
32               for(var i:Number = 0; i < _elementos.length; i++) {
33                   var elemento:ITreeElement = _elementos.getItemAt(i) as ITreeElement;
34                   output += elemento.getInfo();
35               }
36               output += "\n--------------------------------------\n";
37               return output;
38           }
39       }
40   }

Como vemos la clase Rama tiene una propiedad que es una colección de elementos, esta es la que contendrá otras ramas ó hojas que se le vayan agregando.

Algo muy importante es que le pongas mucha atención al método getInfo, ve como iteramos sobre todos los elementos de la rama y delegamos la tarea de obtener la información de los elementos sin importarle sin son ramas o hojas.

Si nos ponemos a pensar un poquito cuando hagamos nuestra clase Hoja, esta tendrá métodos que no tienen ningún significado para esta como addElement y removeElement, ya que las hojas no pueden contener otros elementos.

¿ Qué podemos hacer para solucionar este problema ?

Una solución es poner los métodos sin ningún tipo de implementación o podemos que los métodos que no tienen ningún sentido para la hoja arrojen una excepción, optaremos por la segunda opción.

1   package {
2   
3       public class Hoja implements ITreeElement {
4       
5           public function Hoja() {
6           }
7       
8           function addElement(element:ITreeElement):void {
9               throw new Error("Este método no es posible llamarlo desde una instancia Hoja");
10           }
11       
12           function removeElement(element:ITreeElement):Boolean {
13               throw new Error("Este método no es posible llamarlo desde una instancia Hoja");
14           }
15       
16           function getInfo():String {
17               return "Soy una hoja sana y fuerte.";
18           }
19       }
20   }
21

Ve como en la hoja solamente necesitamos retornar la cadena de información con getInfo, ya que es un elemento único.

Luego aquí va nuestra clase Árbol que el cliente usará para formar su arbolote:

1   package {
2   
3       import mx.collections.ArrayCollection;
4   
5       public class Arbol {
6       
7       
8           private var _nombre:String;
9           private var _peso:String;
10           private var _diametro:String;
11           private var _elementos:ArrayCollection;
12       
13       
14           public function Arbol(nombre:String, peso:String, diametro:String) {
15               _nombre = nombre;
16               _peso = peso;
17               _diametro = diametro;
18               _elementos = new ArrayCollection();
19           }
20       
21           public function get nombre():String {
22               return _nombre;
23           }
24       
25           public function get peso():String {
26               return _peso;
27           }
28       
29           public function get diametro():String {
30               return _diametro;
31           }
32       
33           public function agregarElemento(e:ITreeElement):void {
34               _elementos.addItem(e);
35           }
36       
37           public function obtenerEstructura():void {
38               for(var i:Number = 0; i < _elementos.length; i++) {
39                   var elemento:ITreeElement = _elementos.getItemAt(i) as ITreeElement;
40                   trace(elemento.getInfo());
41               }
42           }
43       
44       }
45   }

Por último un ejemplo de cómo podríamos formar un árbol con ramas y hojas, y al final obtener su estructura interna.

1   var rama1:Rama = new Rama();
2   rama1.addElement(new Hoja());
3   rama1.addElement(new Hoja());
4   rama1.addElement(new Hoja());
5   var rama2:Rama = new Rama();
6   rama2.addElement(new Hoja);
7   rama1.addElement(rama2);
8   var rama3:Rama = new Rama();
9   rama3.addElement(new Rama());
10   var hojaSola:Hoja = new Hoja();
11               
12   var arbol:Arbol = new Arbol("Árbol del Tule", "636 toneladas", "14.05 m");
13   arbol.agregarElemento(rama1);
14   arbol.agregarElemento(rama3);
15   arbol.agregarElemento(hojaSola);
16               
17   arbol.obtenerEstructura();

Es un ejemplo que lo podemos mejorar utilizando el patrón Iterator, en mi siguiente post lo veremos en detalle.

Cualquier comentario ó sugerencia es bienvenida.

Un saludote !