| Basicos::Base::Hijos - Relaciones padre-hijos entre objetos |
Basicos::Base::Hijos - Relaciones padre-hijos entre objetos
package Parent;
use base qw(Middleman);
package Middleman;
use base qw(Basicos::Base::Hijos);
Middleman->children_factory(
method => q(hijos),
class => q(Child),
childname => q(nombre)
);
sub _children_param {
my $self = shift;
return {};
}
package Child;
use base qw(Basicos::Base);
Child->make_accessors(
nombre => undef,
edad => 0
);
package main;
use Parent;
my $obj = Parent->new();
$obj->hijos->newchild('pelaez')->edad(13);
my $hijo = $obj->hijos->newchild( 'coco' );
$hijo->edad(35);
my %todos_mis_hijos = $obj->hijos();
Este paquete está diseñado para crear relaciones padre-hijos entre clases. La idea es utilizar una clase intermedia que mantenga la relación de objetos hijos, a la vez que proporciona un método a la clase padre para acceder a todos ellos ó sólo a uno.
El esquema básico se perfila en la sinopsis de esta documentación. El paquete Parent hereda de la clase intermedia Middleman, que es la encargada de crear los métodos de acceso y creación de hijos.
Después de ejecutar el código que se muestra, las estructuras de datos quedan de esta forma:
$obj => { # Objeto Parent
'Parent::child' => { # Objeto Middleman
'_children' => {
'coco' => { # Objeto Child
'nombre' => 'coco',
'edad' => 35
},
'pelaez' => { # Objeto Child
'nombre' => 'pelaez',
'edad' => '13'
}
}
}
}
=cut
package Basicos::Base::Hijos; use base qw(Basicos::Base); use strict; use warnings; use utf8; use Carp;
use Basicos qw(:all);
our $VERSION = '0.1';
children_factory()
__PACKAGE__->children_factory(
method => q(hijo),
class => q(Child),
childname => q(nombre)
);
Método de clase para automatizar la creación de relaciones padre-hijos entre objetos.
Parámetros
Puede recibir una referencia ó un hash, que debe contener, al menos, los siguientes elementos:
Nombre del método de acceso al objeto padre.
Clase a la que pertenecen los objetos hijos.
Atributo que almacena el nombre del objeto hijo (dentro del propio objeto).
Tomando el ejemplo de arriba, este método de clase lleva a cabo varias tareas:
El objeto padre dispone de un atributo llamado ``_children'', una referencia a un hash, donde guarda los nombres de los objetos hijos y las direcciones de los objetos. Para saber cuál es el nombre del objeto hijo, lee el valor del atributo indicado en el parámetro childname.
Por su parte el hijo debe tener un atributo llamado ``_parent'' donde se almacenará, cada vez que se cree un objeto hijo, la dirección del padre.
Resultados
No hay retorno alguno válido.
El método padre puede ser llamado en cuatro escenarios distintos:
$self->hijo(); En este caso, el método se limita a crear (si no lo está ya) el objeto de la clase I<Middleman> y a inicializar el atributo I<_children> del mismo.
my %lista = $self->hijo(); Realiza lo mismo que el anterior, pero retorna un hash con el contenido del atributo I<_children>.
my $middleman = $self->hijo(); Igual que el primer caso, pero retorna el objeto I<Middleman>. Con el valor devuelto podemos invocar directamente al objeto hijo como en
$middleman->pelaez->get();
que es equivalente a la construcción
$self->hijo->pelaez->get();
my $hijo = $self->hijo('nombre');
if (defined($hijo)) {
...
}
Inicializa como las anteriores, pero retorna la referencia al objeto hijo que le indiquemos. Eso acorta un poco la síntaxis de uso del objeto hijo como en
$hijo->set('a');
$hijo->get();
Este método es más apropiado cuando no sabemos si el objeto hijo existe o no, para evitar usar directamente una referencia nula.
_children_params()
my $info = $self->{_parent}->_children_params();
Este método es una puerta de comunicación entre el objeto padre y los objetos hijos. Dado que ellos ya guardan la referencia al padre en el atributo _parent, hemos ideado este mecanismo para que, dentro del código del objeto hijo, tenga acceso a parámetros globales sin que exista la necesidad de definirlos como variables ó similares.
Asimismo, y dado que el objeto padre no tiene por qué definir éste método, nosotros creamos uno que devuelve siempre un hash vacío como último recurso.
Debe quedar claro que los datos obtenidos a través de este método serán establecidos de antemano por el desarrollador de ambos objetos: padre e hijos.
Resultados
Ninguno encontrado por el momento. Tampoco carencias.
(c) Copyright Víctor Moral <victor@taquiones.net> y Angel Ortega <angel@triptico.com>
the Basicos::Base manpage, the Basicos::Base::Clases manpage
Este programa está bajo licencia GPL (ver perlgpl) y puede distribuirse y/ó modificarse bajo los términos en ella descritos.
| Basicos::Base::Hijos - Relaciones padre-hijos entre objetos |