Accesadores de Perl Moose generados sobre la marcha

attributes

Question

Vea el siguiente fragmento de código de Perl que se basa en Moose:

$BusinessClass->meta->add_attribute($Key => { is        => $rorw,
                                              isa       => $MooseType,
                                              lazy      => 0,
                                              required  => 0,
                                              reader    => sub { $_[0]->ORM->{$Key} },
                                              writer    => sub { $_[0]->ORM->newVal($Key, $_[1]) },
                                              predicate => "has_$Key",
                                            });

Recibo el error:

bad accessor/reader/writer/predicate/clearer format, must be a HASH ref at /usr/local/lib/perl5/site_perl/mach/5.20/Class/MOP/Class.pm line 899

La razón del error es clara: el lector y el escritor deben ser nombres de cadena de funciones.

Pero, ¿qué hacer en este caso específico? No quiero crear una nueva función para cada uno de los cien campos ORM (el atributo ORM aquí es un hash vinculado). Así que no puedo pasar una cadena aquí, necesito un cierre.

Por lo tanto, mis necesidades de codificación resultaron en una contradicción. No se que hacer.

Lo anterior fue un fragmento de código real. Ahora presento un ejemplo mínimo:

#!/usr/bin/perl

my @Fields = qw( af sdaf gdsg ewwq fsf ); # pretend that we have 100 fields

# Imagine that this is a tied hash with 100 fields 
my %Data = map { $_ => rand } @Fields;

package Test;
use Moose;

foreach my $Key (@Fields) {
  __PACKAGE__->meta->add_attribute($Key => { is        => ''rw'',
                                             isa       => ''Str'',
                                             lazy      => 0,
                                             required  => 0,
                                             reader    => sub { $Data{$Key} },
                                             writer    => sub { $Data{$Key} = $_[1] },
                                           });
}

Ejecutarlo da como resultado:

$ ./test.pl 
bad accessor/reader/writer/predicate/clearer format, must be a HASH ref at /usr/lib/i386-linux-gnu/perl5/5.22/Class/MOP/Class.pm line 899
    Class::MOP::Class::try {...}  at /usr/share/perl5/Try/Tiny.pm line 92
    eval {...} at /usr/share/perl5/Try/Tiny.pm line 83
    Try::Tiny::try(''CODE(0x9dc6cec)'', ''Try::Tiny::Catch=REF(0x9ea0c60)'') called at /usr/lib/i386-linux-gnu/perl5/5.22/Class/MOP/Class.pm line 904
    Class::MOP::Class::_post_add_attribute(''Moose::Meta::Class=HASH(0x9dc13f4)'', ''Moose::Meta::Attribute=HASH(0x9dc6b5c)'') called at /usr/lib/i386-linux-gnu/perl5/5.22/Class/MOP/Mixin/HasAttributes.pm line 39
    Class::MOP::Mixin::HasAttributes::add_attribute(''Moose::Meta::Class=HASH(0x9dc13f4)'', ''Moose::Meta::Attribute=HASH(0x9dc6b5c)'') called at /usr/lib/i386-linux-gnu/perl5/5.22/Moose/Meta/Class.pm line 572
    Moose::Meta::Class::add_attribute(''Moose::Meta::Class=HASH(0x9dc13f4)'', ''af'', ''HASH(0x9ea13a4)'') called at test.pl line 18

No sé qué hacer (cómo crear accesos "dinámicos" (similares a los cierres), sin escribir una función individual para cada uno de los 100 campos?)

Answer 1

Creo que cambiar los métodos de lectura y escritura de este tipo requiere un nivel insalubre de locura. Si lo desea, eche un vistazo al código fuente de Class :: MOP :: Method :: Accessor , que se usa debajo del capó para crear los accesors.

En cambio, sugiero simplemente sobrescribir (o adjuntar) la funcionalidad a los lectores generados por Moose utilizando un modificador de método around . Para que funcione con subclases, puede usar Class :: Method :: Modifiers en lugar de Moose around .

package Foo::Subclass;
use Moose;
extends ''Foo'';

package Foo;
use Moose;

package main;
require Class::Method::Modifiers; # no import because it would overwrite Moose

my @Fields = qw( af sdaf gdsg ewwq fsf );    # pretend that we have 100 fields

# Imagine that this is a tied hash with 100 fields
my %Data = map { $_ => rand } @Fields;

my $class = ''Foo::Subclass'';
foreach my $Key (@Fields) {
    $class->meta->add_attribute(
        $Key => {
            is       => ''rw'',
            isa      => ''Str'',
            lazy     => 0,
            required => 0,
        }
    );

    Class::Method::Modifiers::around( "${class}::$Key", sub {
        my $orig = shift;
        my $self = shift;

        $self->$orig(@_);    # just so Moose is up to speed

        # writer
        $Data{$Key} = $_[0] if @_;

        return $Data{$Key};
    });
}

Y luego ejecuta una prueba.

package main;
use Data::Printer;
use v5.10;

my $foo = Test->new;
say $foo->sdaf;
$foo->sdaf(''foobar'');
say $foo->sdaf;

p %Data;
p $foo;

Aquí está el STDOUT / STDERR de mi máquina.

{
    af     0.972962507120432,
    ewwq   0.959195914302605,
    fsf    0.719139421719849,
    gdsg   0.140205658312095,
    sdaf   "foobar"
}
Foo::Subclass  {
   Parents       Foo
    Linear @ISA   Foo::Subclass, Foo, Moose::Object
    public methods (6) : af, ewwq, fsf, gdsg, meta, sdaf
    private methods (0)
    internals: {
        sdaf   "foobar"
    }
}
0.885114977459551
foobar

Como puede ver, Moose realmente no sabe acerca de los valores dentro del hash, pero si usa los accessors, los leerá y escribirá. El objeto Moose se llenará lentamente con nuevos valores cuando use el escritor, pero de lo contrario los valores dentro del objeto Moose realmente no importan.