Here's how a subclass might use it:

package Foo::People;
use Foo::PersistentObject;
@ISA = 'Foo::PersistentObject';
use strict;

my %ARGS = (
    _id      => 'people_id',
    _table   => 'people',
    _mapping => {
        id         => 'people_id',
        first_name => 'first',
        last_name  => 'last'
    }
);

sub new {
    my ($class,$id) = @_;
    $ARGS{_open_this_id} = $id if $id;
    my $self = $class->SUPER::new( %ARGS );    
}

sub get_list {
    my $class = shift;
    $class->SUPER::get_list( %ARGS );
}

1;
[download]

Note: The intent of the %mapping hash is to provide external method names that map to internal field names so that I can change field names in the database without the programmer needing to worry about the interface.

The programmer could use this class as follows:

my $person = Foo::People->new;
$person->open( $id );

my $person = Foo::People->new( $id ); # same thing as above

my $people = Foo::People->get_list; # get a list of all people (as obj
+ects)
[download]

The problem lies in the fact that I chose to overload the constructor. See that line with the _open_this_id line? Well, if I call get_list, the super class method looks like this:

sub get_list {
    my ($class, %args) = @_;
    my ($id_name,$table) = @args{qw(_id _table)};
    my $sql = "SELECT $id_name FROM $table";

    # the database object is deliberately unavailable to the
    # programmers
    my @objects;
    my $ids = $DBO->_arrayref( $sql );
    foreach my $id ( @$ids ) {
        push @objects => $class->new(%args,open_id => $id);
    }
    return \@objects;
}
[download]

You can see that I am creating a list of objects and as I am now passing an argument list to new, it thinks that there is an id to open, but this id winds up being one of the keys of the %args hash. This causes my id to be incorrect and the constructors fail. I got around this by doing the following:

sub new {
    my ($class,$id) = @_;
    $ARGS{open_id} = $id if $id;
    $class->_new( %ARGS );    
}

sub _new { 
    my $class = shift;
    $class->SUPER::new( @_ );
}
[download]

Then, in the Foo::PersistentObject::get_list method, I call the _new class method instead of new. It seems to solve the problem, yet it also seems a bit hackish at the same time. Having to simulate overloading based on method signatures is making this code considerably more ugly.

Can anyone offer advice on a better strategy here? Also, I'm curious to know if the whole idea might be unsound. I think that it's reasonable, but I know there are those who assert that inheritance should be avoided in Perl.

Cheers,
Ovid

New address of my CGI Course.
Silence is Evil (feel free to copy and distribute widely - note copyright text)