| Basicos::Base - Métodos de lectura/escritura para clases |
make_accessors()make_all_accessors()new()clone()init()get()getall()set()_dump()_list_of_attributes()
$self->init_field( $field, $value );
Inicializa un campo al valor dado. Si $field debe contener una instancia, se crea un objeto nuevo de la clase especificada, o se almacena directamente en caso contrario.
$obj->setall( %params );
Asigna un conjunto de valores a un objeto; si el objeto contiene un método ``accessor'', se utiliza; si no, se asigna directamente.
Basicos::Base - Métodos de lectura/escritura para clases
package MyPackage;
use base qw(Basicos::Base);
my %campos = (
name => undef,
address => {
street => undef,
state => undef,
zipcode => undef
}
);
MyPackage->make_accessors ( %campos );
sub _initialize {
my $self = shift;
$self->{_otro_campo} = '';
return;
}
sub _post_mutate {
my $self = shift;
my $field = shift;
if ($field eq '...') {
1;
}
return;
}
package main;
use MyPackage;
my $obj = MyPackage->new(
name => q(nombre),
fields => [ qw( nuestros campos ) ]
);
$obj->address->street('Rue Percebe, 13');
=head1 DESCRIPTION
Este módulo sirve como clase base para facilitar la creación de posteriores clases derivadas.
Proporciona un juego de métodos a un paquete que herede de él, de manera que es posible:
Para hacer uso de éste módulo se deben seguir las siguientes indicaciones:
Esto se lleva a cabo mediante el uso de use base
qw(Basicos::Base).
Usando el método de clase make_accessors y teniendo en
cuenta que:
_initialize() en nuestro paquete. Será llamada después de
new() e init().
A partir de ahora es posible crear subclases automágicamente; para ello
basta con inicializar el valor del campo a otro hash conteniendo los
campos de la subclase. Basicos::Base crea una nueva subclase uniendo el
nombre de la clase principal al nombre del campo, y le añade las herencias
correspondientes. Ojo, que no es una clase derivada, es una clase automática
que desciende directamente de Basicos::Base.
Un ejemplo lo explica mejor:
package MyPackage;
use base qw(Basicos::Base);
MyPackage->make_accessors(
nombre => 'default',
fisico => {
altura => undef,
peso => undef
},
aniversario => {
anio => undef,
dia => undef,
mes =>
}
);
package main;
my $person = MyPackage->new();
$person->name('fulanito');
$person->fisico->altura(1,348);
$person->fisico->peso(2354);
$person->fisico->anio(2015);
$person->fisico->mes(1);
$person->fisico->dia(20);
Tras la llamada a make_accessors se han creado las siguientes clases:
y en la clase MyPackage han quedado registrados dos métodos (fisico y
aniversario) con métodos básicos diferenciados de esta forma:
init)
Se crea un objeto de la subclase correspondiente, con los valores que se indicaron en la definición.
get)
Retorna la referencia al objeto.
set)
Se produce una excepción debido a que estos métodos son de sólo lectura.
make_accessors()
package MyPackage;
use base qw(Basicos::Base);
MyPackage->make_accessors( {
'atributo_publico' => '',
'_atributo_privado' => 0
} );
Este método de clase es el encargado de crear los métodos de lectura/escritura para los atributos del objeto, dentro del espacio de nombres del paquete llamante.
Parámetros
Referencia a un hash (ó un hash directamente) cuyas claves son los nombres de los campos, y consecuentemente los nombres de los métodos.
Los valores se guardan y se usan como valores por omisión en las siguientes llamadas a new(), init() y clone().
Para diferencias atributos públicos y privados se debe prefijar el nombre con un carácter subrayado, en cuyo caso no se crean métodos de lectura/escritura para dichos atributos.
Cabe señalar que si el valor de un campo apunta a un hash no vacío se creará una subclase tal y como se explica en la sección anterior.
Si es necesario crear métodos de acceso para todos los
atributos utilice el método de clase make_all_accessors
en su lugar. Funciona igual, pero no ignora ningún atributo
a excepción de los que se mencionan a continuación:
Proporciona una lista de nombres de parámetros para los que será obligatorio recibir un valor en la creación del objeto.
'name' => undef,
'id' => 0,
'__NEW__' => [ qw(name) ]
...
my $obj = MyPackage->new ( 'nombre', { id => 1 } );
No es necesario nombrar el parámetro y es posible proporcionar después una lista con el resto de los parámetros.
Proprociona una referencia a una función que inicializará el
objeto, en lugar de buscar un método initialize en el
espacio de nombres del paquete llamador.
make_all_accessors()Este método es idéntico en uso a make_accessors, excepto
que sí crea un método de lectura/escritura para los
atributos privados. Utilizado en subclases principalmente.
new()
use MyPackage;
my $obj = MyPackage->new( %valores );
Crea un nuevo objeto de tipo MyPackage y lo inicializa con los valores del hash recibido.
Para ver cómo se efectúa el proceso de inicialización de valores, ver el método L<Basicos::Base/init>.
Parámetros
Hash con los pares variable-valor para inicializar el objeto.
Resultados
Referencia al nuevo objeto creado o un valor nulo en caso de fallo.
clone()
use MyPackage;
my $obj = MyPackage->new();
my $other = $obj->clone();
Duplica literalmente un objeto de clase I<MyPackage> en otro
nuevo (de la misma clase obviamente) y copia los valores que
conserva en ese momento en todos sus campos, públicos y
privados.
Resultados
Referencia al nuevo objeto creado o un valor nulo en caso de fallo.
init()
my $obj = MyPackage->new();
$obj->init( %values );
Inicializa los atributos de un objeto con los valores indicados.
En caso de no proporcionar ningún valor el objeto se inicializa con los valores declarados en la llamada a make_accessors.
Si este método se encuentra con un campo que no existe, intenta ver si existe un método así en el paquete derivado (MyPackage en el ejemplo). En caso afirmativo llama a ese método pasándole como parámetros los valores del elemento.
Parámetros
Lista de pares atributo-valor para modificar.
Resultados
Referencia al objeto.
get()
my $value = $obj->get('atributo_publico');
Permite leer el valor de un atributo de un objeto. No está diseñada, en principio, para ser llamada directamente.
Parámetros
Nombre del atributo que se pretende leer.
Resultados
Valor del atributo ó nulo si hay un error.
getall()my %data = $obj->getall();
Recupera como un hash la estructura completa del objeto. Si alguno de los componentes es a su vez un objeto, se rellenará con una copia de los datos del mismo.
set()
$obj->set('atributo_publico','nuevo valor');
Permite escribir en un atributo de un objeto.
Parámetros
Nombre del atributo sobre el que se quiere escribir.
Nuevo valor (sin comprobación alguna de tipo, naturalmente).
Resultados
Nuevo valor almacenado ó nulo si hay algún error.
_dump()
my $texto = $obj->_dump();
Vuelca los contenidos totales del objeto mediante the Data::Dumper manpage en una cadena de texto, con los nombres correctamente situados.
Resultados
Salida del método Dump in the Data::Dumper manpage.
_list_of_attributes()
my @list = $self->_list_of_attributes();
Dado un objeto devuelve la lista de atributos -tanto públicos, como privados- de los que tiene constancia.
Resultados
_make_accessors().
(c) Copyright Víctor Moral <victor@taquiones.net> y Angel Ortega <angel@triptico.com>
Este programa está bajo licencia GPL (ver perlgpl) y puede distribuirse y/ó modificarse bajo los términos en ella descritos.
| Basicos::Base - Métodos de lectura/escritura para clases |