Patrón Composite

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 96 de 107.

El patrón Composite te permite tratar objetos individuales y grupos de objetos de manera uniforme. Mientras que State cambia el comportamiento basándose en el estado interno, Composite construye estructuras de árbol donde tanto las hojas como los contenedores comparten la misma interfaz.

Este patrón es perfecto para estructuras jerárquicas como sistemas de archivos, organigramas o componentes de interfaz de usuario. En Go, definimos una interfaz común que implementan tanto los elementos individuales como los contenedores:

type Component interface {
    GetSize() int
}

type File struct {
    Name string
    Size int
}

func (f File) GetSize() int {
    return f.Size
}

El compuesto (contenedor) contiene hijos e implementa la misma interfaz agregando sus resultados:

type Folder struct {
    Name     string
    Children []Component
}

func (f *Folder) Add(c Component) {
    f.Children = append(f.Children, c)
}

func (f Folder) GetSize() int {
    total := 0
    for _, child := range f.Children {
        total += child.GetSize()
    }
    return total
}

Ahora puedes anidar carpetas dentro de carpetas, y llamar a GetSize() funciona de manera idéntica ya sea que se trate de un solo archivo o de un árbol de directorios completo:

docs := &Folder{Name: "docs"}
docs.Add(File{Name: "readme.txt", Size: 100})
docs.Add(File{Name: "notes.txt", Size: 50})

root := &Folder{Name: "root"}
root.Add(docs)
root.Add(File{Name: "config.json", Size: 25})

fmt.Println(root.GetSize())  // 175

Composite es ideal cuando necesitas representar jerarquías de parte-todo y quieres que los clientes traten a los objetos individuales y a las composiciones de manera idéntica.

Desafío

Fácil

¡Vamos a construir un sistema de organigrama utilizando el patrón Composite! Crearás una estructura donde tanto los empleados individuales como los departamentos (que contienen empleados u otros departamentos) puedan ser tratados de manera uniforme, lo cual es perfecto para calcular los salarios totales en cualquier parte de la organización.

Organizarás tu código en tres archivos:

component.go: Define la interfaz común que implementarán tanto los individuos como los grupos.
Crea una interfaz OrgComponent con dos métodos:
- GetSalary() int — devuelve el salario total de este componente
- GetName() string — devuelve el nombre del empleado o departamento
organization.go: Implementa tanto el tipo hoja (empleado individual) como el tipo compuesto (departamento).
Crea una estructura Employee con los campos Name (string) y Salary (int). Su método GetSalary() devuelve su propio salario, y GetName() devuelve su nombre.

Crea una estructura Department con un campo Name (string) y un slice Members que contenga elementos OrgComponent. Añade un método Add(c OrgComponent) para agregar miembros. Su método GetSalary() debe devolver la suma de los salarios de todos los miembros, y GetName() devuelve el nombre del departamento.
main.go: Construye una estructura organizativa y calcula los salarios.
Lee el número de empleados. Para cada empleado, lee su nombre y salario, creando instancias de Employee. Luego lee el número de departamentos. Para cada departamento, lee su nombre y la cantidad de índices de miembros, seguidos de esos índices (basados en 0, refiriéndose a empleados o departamentos creados previamente en orden de creación).

Después de construir la estructura, lee un índice final e imprime el nombre de ese componente y el salario total en el formato: [name]: [salary]

Se proporcionarán las siguientes entradas:

Número de empleados, luego el nombre y salario de cada empleado en líneas separadas
Número de departamentos, luego el nombre de cada departamento, el recuento de miembros y los índices de los miembros
Índice final a consultar

Por ejemplo, dado:

3
Alice
50000
Bob
60000
Carol
55000
1
Engineering
3
0
1
2
3

Tu salida debería ser:

Engineering: 165000

Y dado:

4
Alice
50000
Bob
60000
Carol
55000
Dave
70000
2
Dev
2
0
1
QA
2
2
3
4

Tu salida debería ser:

QA: 125000

Y dado:

2
Alice
50000
Bob
60000
0
1

Tu salida debería ser:

Bob: 60000

Observa cómo GetSalary() funciona de manera idéntica ya sea que lo llames para un solo empleado o para un departamento entero: ¡el patrón Composite te permite tratar a individuos y grupos de manera uniforme a través de la misma interfaz!

Hoja de referencia

El patrón Composite trata a los objetos individuales y a los grupos de objetos de manera uniforme a través de una interfaz compartida. Es ideal para estructuras jerárquicas como sistemas de archivos, organigramas o componentes de interfaz de usuario (UI).

Define una interfaz común que implementen tanto los elementos individuales como los contenedores:

type Component interface {
    GetSize() int
}

Implementa la hoja (elemento individual):

type File struct {
    Name string
    Size int
}

func (f File) GetSize() int {
    return f.Size
}

Implementa el compuesto (contenedor) que contiene hijos y agrega sus resultados:

type Folder struct {
    Name     string
    Children []Component
}

func (f *Folder) Add(c Component) {
    f.Children = append(f.Children, c)
}

func (f Folder) GetSize() int {
    total := 0
    for _, child := range f.Children {
        total += child.GetSize()
    }
    return total
}

Ejemplo de uso que muestra el tratamiento uniforme de elementos individuales y composiciones:

docs := &Folder{Name: "docs"}
docs.Add(File{Name: "readme.txt", Size: 100})
docs.Add(File{Name: "notes.txt", Size: 50})

root := &Folder{Name: "root"}
root.Add(docs)
root.Add(File{Name: "config.json", Size: 25})

fmt.Println(root.GetSize())  // 175

Pruébalo tú mismo

package main

import "fmt"

func main() {
	// Leer el número de empleados
	var numEmployees int
	fmt.Scanln(&numEmployees)

	// Almacenar todos los componentes (empleados y departamentos) en orden de creación
	var components []OrgComponent

	// TODO: Leer el nombre y el salario de cada empleado
	// Crear instancias de Employee y añadirlas al slice components
	for i := 0; i < numEmployees; i++ {
		var name string
		var salary int
		fmt.Scanln(&name)
		fmt.Scanln(&salary)
		// TODO: Crear el empleado y añadirlo a components
	}

	// Leer el número de departamentos
	var numDepartments int
	fmt.Scanln(&numDepartments)

	// TODO: Leer el nombre de cada departamento, el recuento de miembros y los índices de los miembros
	// Crear instancias de Department, añadir miembros por índice y añadirlas a components
	for i := 0; i < numDepartments; i++ {
		var deptName string
		var memberCount int
		fmt.Scanln(&deptName)
		fmt.Scanln(&memberCount)
		// TODO: Crear el departamento, leer los índices de los miembros, añadir los miembros y añadir a components
	}

	// Leer el índice final para consultar
	var queryIndex int
	fmt.Scanln(&queryIndex)

	// TODO: Imprimir el nombre del componente y el salario total en el formato: [name]: [salary]
	// Ejemplo: fmt.Printf("%s: %d\n", name, salary)
}