If all you want is something like SUPER that acts in a breadth-first-search way, you can use something like this: (unfortunately overriding the SUPER namespace doesn't work -- it's more magical than that)

package SUPERB;
use Carp;

sub AUTOLOAD {
    my $self   = shift;
    my $caller = caller;
    $AUTOLOAD  =~ s/.*:://;
    
    for my $method ($AUTOLOAD, "AUTOLOAD") {
        my @queue = @{"$caller\::ISA"};

        while (@queue) {
            my $class = shift @queue;

            if ( *{"$class\::$method"}{CODE} ) {
                my $call = "$class\::$AUTOLOAD";
                return $self->$call(@_);
            } else {
                push @queue, @{"$class\::ISA"};
            }
        }
    }
    
    my $class = ref $self || $self;
    croak qq[Can't locate object method "$AUTOLOAD" via package "$clas
+s"];

}

1;
[download]

Now we can achieve this:

use SUPERB;

package Base;
sub foo { print "Base::foo\n"; }
sub bar { print "Base::bar\n"; }
sub baz { print "Base::baz\n"; }

package A; @ISA = qw/Base/;
sub foo { print "A::foo\n"; }

package B; @ISA = qw/Base/;
sub bar { print "B::bar\n"; }

package C; @ISA = qw/A B/;
sub foo { print "C::foo\n"; shift->SUPERB::foo; }
sub bar { print "C::bar\n"; shift->SUPERB::bar; }
sub baz { print "C::baz\n"; shift->SUPERB::baz; }

package main;

my $c = bless [], 'C';
$c->foo;
$c->bar;
$c->baz;

__OUTPUT__
C::foo
A::foo
C::bar
B::bar
C::baz
Base::baz
[download]

The important thing to notice is that SUPERB::bar correctly dispatches to B::bar instead of Base::Bar.

Another variant on this is to have the actual @ISA hierarchy searched in a BFS way, for when you don't use SUPER -- For example, in the code above, say we removed all the subs in the "C" package (maybe we don't need to override them at all in this subclass) and still wanted to get B::bar instead of Base::bar.

To do this, you have to use your own mechanism instead of Perl's @ISA hierarchy. You can use AUTOLOAD to dispatch the calls up the hierarchy however you want. The problem is that Perl won't call the subclass' AUTOLOAD if the actual method exists higher up. To get around this, you can not declare @ISA in the subclass and use a private list of isa-classes. This way, AUTOLOAD gets called right away if the method is unimplemented in the subclass. This little package provides a simple way to do it:

package bfs_dispatch;
use Carp;

sub import {
    my ($x, @isa) = @_;
    my $caller    = caller;

    *{"$caller\::AUTOLOAD"} = sub {
        my $self = shift;
    
        $AUTOLOAD =~ s/.*:://;
    
        for my $method ($AUTOLOAD, "AUTOLOAD") {
            my @queue = @isa;
    
            while (@queue) {
                my $class = shift @queue;
    
                if ( my $code = *{"$class\::$method"}{CODE} ) {
                    my $call = "$class\::$AUTOLOAD";
                    return $self->$call(@_);
                } else {
                    push @queue, @{"$class\::ISA"};
                }
            }
        }
    
        my $class = ref $self || $self;
        croak qq[Can't locate object method "$AUTOLOAD" via package "$
+class"];
    };

}

1;
[download]

You call it from within a package like this: use bfs_dispatch qw/base1 base2/;, with the isa information provided. So in the code example above, we'd replace:

## replace this:

package C; @ISA = qw/A B/;
sub foo { print "C::foo\n"; shift->SUPERB::foo; }
sub bar { print "C::bar\n"; shift->SUPERB::bar; }
sub baz { print "C::baz\n"; shift->SUPERB::baz; }

## with this:

package C;
use bfs_dispatch qw/A B/;

## methods deleted, lets see if the method dispatcher finds the correc
+t one!
[download]

Then when we run that code, we get what we expect:

__OUTPUT__
A::foo
B::bar
Base::baz
[download]

There are problems with this second approach that may be obvious to you: SUPER (and SUPERB) won't work because there is no @C::ISA. Also UNIVERSAL::isa and UNIVERSAL::can will be equally confused. Thus, this is probably a very bad idea. If you want the behavior of BFS method dispatch, you are probably better off declaring all the methods in the subclass like this:

package C;
@ISA = qw/A B/;
sub foo { $_[0]->SUPERB::foo(@_[1..$#_]); }
sub bar { $_[0]->SUPERB::bar(@_[1..$#_]); }
sub baz { $_[0]->SUPERB::baz(@_[1..$#_]); }
[download]

Although this approach screams maintainability problems as well.

---

---

• Are you posting in the right place? Check out Where do I post X? to know for sure.
• Posts may use any of the Perl Monks Approved HTML tags. Currently these include the following:

  <code> <a> <b> <big> <blockquote> <br /> <dd> <dl> <dt> <em> <font> <h1> <h2> <h3> <h4> <h5> <h6> <hr /> <i> <li> <nbsp> <ol> <p> <small> <strike> <strong> <sub> <sup> <table> <td> <th> <tr> <tt> <u> <ul>

• Snippets of code should be wrapped in <code> tags not <pre> tags. In fact, <pre> tags should generally be avoided. If they must be used, extreme care should be taken to ensure that their contents do not have long lines (<70 chars), in order to prevent horizontal scrolling (and possible janitor intervention).
• Want more info? How to link or How to display code and escape characters are good places to start.