So, yes, SUPER:: is strictly for subroutines. Although you can get to the current package's variable, it will have to be symbolically e.g

sub test {
  no strict 'refs';
  print "name: ", ${"$_[0]::name"}, "\n";
}

$foo::name = "I'm a foo";
$bar::name = "I'm a bar";

@foo::ISA = @bar::ISA = 'main';

foo->test();
bar->test();

__output__

name: I'm a foo
name: I'm a bar
[download]

Test->new(); # Calls Obj::new
Test::new(); # Fails
$Test::$foo; # Fails for the same reason that Test::new did
[download]

Therefore you will either have to arrange to be using method lookups (exactly like perrin suggested) or you will have to figure out the package that you want to look things up in and look stuff up dynamically on the fly using typeglobs etc.

Of the two options, I would think that methods are a cleaner way to go. But if you want...

sub test {
    my $self = shift;
    my $class = ref($self) || $self;
    local $Name;
    {
      no strict 'refs';
      *Name = \${"$class\::Name"};
    }
    print $Name;
}
[download]

The "SUPER" keyword only works on method calls. The way you used it, it just gets treated as the literal name of a package.

Cool. That makes me feel better. Basically, I know there are several ways to do this. The real code is a report writer. There are 3 variables I want to be able to change in a child class. Then I want to over load two function header() and footer() if necessary. Brain is fried, but basically, here's what I'm trying to accomplish.

Base Class is the Report Writer. It doesn't care what its writing, it writes things. I want to inherit from it and change 3 variables, the sheetname, the header array (column names), and the fields hash (which is kinda cool, it knows how to extract each field from a generic hash which is used to generate 7 different reports). I'm lazy (this is why I love perl) and I wanted to basically do this:

package Report::Writer::Test;

use vars qw/@ISA/;

@ISA=qw/Report::Writer/;

$SheetName = "Test";
@HEADER = qw/I AM TESTING/;
%Fields = (
   I  => sub { return uc $_[0]->{firscol} },
   AM => 'secondcol',
   TESTING => 'PLACE HOLDER'
);
[download]

The end result, is based on my Report::Writer module, I wouldn't have to write anything else to make Report::Writer::Test work.

broquaint's solution was what I was looking for. I'll investigate Class::Data::Inheritable to see if it does what I want it to do. Thank you for the suggestion.

-brad..

Data you want to be inheirtable should go in the reference you are blessing (usually a hash). Use lexical variables (declared my at the top of your package) for private data.

Yes, I agree. This was more of a laziness thing than anything else. I have a lot of perl OO experience, just I had never attempted the package variable overloading before and was crossing my fingers that there'd be a way to do it. I understand why its not necessarily a good idea, but perhaps there are some cases where it could be useful (see my previous post). Maybe something like this:

our $SheetName is overload;
[download]

Maybe I'll look at doing something along those lines one day. I can't imagine it'd be too difficult. Or maybe something like C's extern, which says "this variable will be defined elsewhere" where elsewhere means a sub class of the current class. Uhm. I'm operating between Abstraction and Interfaces, and its confusing.

Does anyone see any value in this?


-brad..

Use subs instead of data, so your example becomes:

package Obj;

use strict;

sub name { undef }

sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;
    my $self = bless {}, $class;

    return $self;
}

sub test {
    my $self = shift;
    print $self->name, " \n";
}

package Test;

use strict;

our @ISA=("Obj");

sub name { 'Testing' }

package main;

my $t = new Test;

$t->test;
[download]