package MyAutoloadDemo;

use strict;
use warnings;
use Carp;

our $AUTOLOAD;

sub new {
    my $class = shift;
    my $self  = {};
    $self->{'data'}->{'name'} = 'spiros';
    $self->{'data'}->{'address'} = 'london';
    bless $self, $class;
    return $self;
}

sub AUTOLOAD {
    my $self = shift;
    my $type = ref $self;

    my $name = $AUTOLOAD;
    $name =~ s/.*://;   # strip fully-qualified portion

    if (!exists $self->{data}->{$name} ) {
        croak "Can't access $name field in class $type";
    }

    return $self->{data}->{$name};   
 }

1;
[download]

use MyAutoloadDemo;

my $demo = MyAutoloadDemo->new();
warn $demo->name;
warn $demo->address;
warn $demo->unknown;
[download]

spiros at test.pl line 4.
london at test.pl line 5.
Can't access unknown field in class MyAutoloadDemo at test.pl line 6
[download]

for ($self->{data}) {
  $_->{name} = 'spiros';
  $_->{address} = 'london';
}
[download]

for ($self->{data}) {
  @$_{qw(name address)} = qw(spiros london);
}
[download]

Or even

@{$self->{data}}{qw(name address)} = qw(spiros london);
[download]

I'm not sure I'm too keen on the AUTOLOAD-based suggestions. I would have almost suggested Object::Tiny, which is probably one of the nicest ways of doing what you want... except that it will fall apart on the fact that the elements in question are all hanging off a subkey. And I suspect most other packages of this nature will, as well.

You could of course steal the code from Object::Tiny::import to inject the accessors and have them fetch the information from the correct part of your object. Or restructure the innards of your object to lift them up to the top level. Or delegate them to a sub-object... the possibilities are endless.

package foo;

use strict;
use warnings;

sub new {
    my $class = shift;
    my $self  = {};
    $self->{data}   = undef;
    bless ($self, $class);
    return $self;
}

# setter and getter
sub data {
  my ( $self, $attr ) = @_;
  $self->{'data'}->{$attr} = $attr if (defined($attr));
  return $self->{'data'}->{$attr};
}
1;
__END__
[download]

$ perl -l
use foo;
use strict;
use warnings;

my $foo = foo::->new();
$foo->data('bar', 42);
print $foo->data('bar');
__END__
bar
[download]

You may also be interested in something along the lines of Class::MethodMaker which will let you declare attributes and build your accessor subs for you (without resorting to AUTOLOAD evilness).

sub data
 {
   my ( $self, $attr ) = @_ ;
   return $self->{'data'}->{$attr} ;
 }
[download]

Apologies, I should have been more clear. I want the sub names to be identical to the keys of the attributes which they fetch. For example:

sub name would return $self->{'data'}->{'name'}
sub address would return $self->{'data'}->{'address'}
[download]

etc

maybe perlsub can help

sub AUTOLOAD
 {
   my ($self, $field ) = @_ ;
   (my $sub = $AUTOLOAD) =~ s/.*::// ; 
   return $self->{'data'}->{$sub} ;
 }
[download]

The code is not tested!

LuCa

package Foo;
use warnings; use strict;

foreach my $att (qw/name address age sex geek_code/) {

  no strict 'refs';

  *$att = sub {
    my $self = shift;
    return $self->{data}->{$att};
  };

}
[download]

sub _data { $_[0]{data}{$_[1] }
sub name { $_[0]->_data( 'name' ) }
sub address { $_[0]->_data( 'address' ) }
[download]

I've not seen this suggested yet:

{
    no strict qw(refs);
    foreach my $method ( keys %{ $self->{'data'} } ) {
        *{$method} = sub {
            my ( $self ) = @_;
            return $self->{'data'}->{$method};
        };
    }
}
[download]

Cheers, Tim

Update: I beg your pardon, snoopy beat me to it :-)

Unless you absolutely positively want exactly that internal data structure, you can solve the general problem with speed and elegance by using one of the Class::Accessor modules.

That gives you a mature, extensible and (in my opinion) well-designed solution to the problem and others like it in your codebase.

Of course, it's possible that this isn't dynamic enough for you, and that you already know Class::Accessor like the back of your hand and the CTO insists that the API is frozen and so on. But if not, I'd really recommend you use Class::Accessor (or Class::Accessor::Fast or Class::Accessor::Faster). I bet you could make a factory on top of that if you really need one.

Anyhow, here's a simple example of that module in action:

package Foo;

use strict;
use warnings;

use base qw(Class::Accessor);
__PACKAGE__->mk_accessors(qw(spiro london));

1;
[download]

Meanwhile, in a nearby t/*.t:

my $foo = Foo->new( { spiro => 'Agnew', london => 'England' } );
isa_ok( $foo, 'Foo' );
is( $foo->spiro,  'Agnew',   "spiro" );
is( $foo->london, 'England', "london" );
ok( $foo->spiro('Not really Agnew'), "set spiro" );
ok( $foo->london('Ontario'),         "set london" );
is( $foo->spiro,  'Not really Agnew', "spiro" );
is( $foo->london, 'Ontario',          "london" );
[download]