Re: Inheritable pragma ... or how I learnt perls' compilation order

Some of that sounds a bit off. Taking just the first-

Fully support abstract methods in as much as a call to a non-overridden abstract (by design) method causes the code to croak or otherwise blow up
...
The first is/was fairly trivial - via judicious use of a parameterised import routine initialising a package scoped hash and an AUTOLOAD routine using said package variable to categorise uncaught method calls.

Methods (object oriented code) should have no use for import, and AUTOLOAD is not for doing abstract parent methods. For those, you just write/stub the method with the croak/die/confess in it. That way any successful call has to have come from a subclass. Maybe you're doing something different but the way it sounds, it sounds like you're going about coding up your specs entirely wrong. :(

Comment on Re: Inheritable pragma ... or how I learnt perls' compilation order Download Code

Replies are listed 'Best First'.
Re^2: Inheritable pragma ... or how I learnt perls' compilation order by Bloodnok (Vicar) on Aug 06, 2008 at 09:54 UTC
Hi , ... sounds like my description wasn't the best in the world. `import` is used solely for the (pure abstract) inheritor to define the interface it expects its inheritors to implement. `AUTOLOAD` is used solely to catch unimplemented methods, mutators etc. and provide a categorised `croak`. In outline, the implementation was along the following lines (I'm afraid I havn't got the actual code to hand at the moment - it's on a memory stick @ work & I'm working from home at the time of writing - doncha just hate it when that happens)... package AbstractBase; use strict; use warnings; use Carp qw/confess/; use Storable qw/dclone/; my %DEF_INTERFACE = ( methods => [], mutators => [], ); use vars qw/%INTERFACES/; sub import { my ($self, $caller) = (shift, caller); %INTERFACES{$caller} = dclone { (%DEF_INTERFACE), @_ }; } sub AUTOLOAD { my $self = shift; (my $method = $AUTOLOAD) =~ s/(.*::)//; my $interface = $INTERFACES{$1}; croak "Abstract method not instantiated: $method" if grep /^$method$/, @{$interface->{methods}}; croak "Mutator method not instantiated: $method" if grep /^$method$/, @{$interface->{mutators}}; croak "Undefined interface component: $method"; } [download] At last, a user level that overstates my experience :-))	[reply] [d/l] [select]

Replies are listed 'Best First'.

Re^2: Inheritable pragma ... or how I learnt perls' compilation order
by Bloodnok (Vicar) on Aug 06, 2008 at 09:54 UTC

... sounds like my description wasn't the best in the world.
import is used solely for the (pure abstract) inheritor to define the interface it expects its inheritors to implement.
AUTOLOAD is used solely to catch unimplemented methods, mutators etc. and provide a categorised croak.

In outline, the implementation was along the following lines (I'm afraid I havn't got the actual code to hand at the moment - it's on a memory stick @ work & I'm working from home at the time of writing - doncha just hate it when that happens)...

package AbstractBase;

use strict;
use warnings;

use Carp qw/confess/;
use Storable qw/dclone/;

my %DEF_INTERFACE = (
  methods  => [],
  mutators => [],
);

use vars qw/%INTERFACES/;

sub import {
  my ($self, $caller) = (shift, caller);

  %INTERFACES{$caller} = dclone { (%DEF_INTERFACE), @_ };
}

sub AUTOLOAD {
  my $self = shift;
  (my $method = $AUTOLOAD) =~ s/(.*::)//;

  my $interface = $INTERFACES{$1};

  croak "Abstract method not instantiated: $method" if
    grep /^$method$/, @{$interface->{methods}};
  croak "Mutator method not instantiated: $method" if
    grep /^$method$/, @{$interface->{mutators}};

  croak "Undefined interface component: $method";
}
[download]

At last, a user level that overstates my experience :-))

[reply]
[d/l]
[select]