Blogaria

Before, I used to write getters and setters for all data fields in my Perl classes. For example:

package Animal;
sub new {
    # ...
}

sub name {
    my ($self, $val) = shift;
  
    # If $val is given then this method is considered a
    # 'setter': store the value in this object.
    $self->{name} = $val if ($val);

    # Now do the 'getter' thing, return the contained data.
    return $self->{name};
}

my $dog = Animal->new();
$dog->name('Spot');
print("My dog is named ", $dog->name(), "\n");

sub name {
    $_[0]->{name} = $_[1] if ($_[1]);
    return $_[0]->{name};
}

The only drawback of this approach is that classes tend to contain a lot of repetitive code. The above hypothetical Animal would have a method name() to wrap a datafield name, next it might have a method nr_of_legs() to wrap a datafield nr_of_legs, and so on. You get the idea.

Wouldn't it be nice if, when coding the class, one wouldn't have to hand-craft such repetitive getters and setters? Well, exactly this is possible using Perl's automagical autoloading. Here's how it works:

• When a non-existing method is called on an object, Perl tries to invoke the method AUTOLOAD (if such method exists).
• Whilst doing so, the invoked name is stored in a class variable $AUTOLOAD (if such a variable exists).
• Hence, if you craft a method AUTOLOAD, which inspects a variable $AUTOLOAD to find out the non-existing name, then that method can emulate what the non-existing getter/setter should be doing!

Time for an example. You can download the below code as automatic.pl. The code has in one file a package called Generic, where the automagic is implemented. Then the code is tested below that. I wonder if Donald Fagen had such fine automated aids to help him with his text writing?

#!/usr/bin/perl

use strict;

{
    package Generic;

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

    our $AUTOLOAD;
    sub AUTOLOAD {
	my ($self, $val) = @_;
	$self->{$AUTOLOAD} = $val if ($val);
	return $self->{$AUTOLOAD};
    }

    1;
}

my $r = Generic->new();
$r->title('girl');
$r->name('Ruby');
$r->lacks('pretty');
$r->question('when will you be mine');

print("I've got a ", $r->title(), " and ", $r->name(), " is her name\n",
      "She ain't real ", $r->lacks(), " but I love her just the same\n",
      $r->name(), " ", $r->name(), " ", $r->question(), "?\n");

# Standard stuff...
package Generic;
sub new {
    # ...
}

# Autoload version that allows only getter/setters title, name, lacks
# and question. All others are considered an error. You get the idea..
my $AUTOLOAD;
sub AUTOLOAD {
    my ($self, $val) = @_;

    # These are the allowed methods
    my %allowed = (title => 1, name => 1, lack => 1,
		   question => 1);

    # Here's the requested method: $AUTOLOAD without method name
    my $requested = $AUTOLOAD;
    $requested =~ s{.*::}{};

    # Check that this is allowed..
    die("Method not allowed\n") unless ($allowed{$requested});

    # Do the automagic.
    $self->{$requested} = $val if ($val);
    return $self->{requested};
}