I suggest NOT exporting anything explicitly in your package/modules. Instead, call the subs by their fully-qualified names, such as coloTotals::process(). This also makes your intentions clear in your code.

That was it... thanks for the clarification

BTW, Exporter is not used for object-oriented modules. It is used to exports functions into a namespace. Instead of calling:

ColoTotals::init();
<code>

You can do:

<code>
use ColoTotals;
init();
[download]

my $totals = ColoTotals->new();
$totals->init();
$totals->process();
$totals->finish();
[download]

Here is a super-simple OO framework for you.

Processor.pm

package Processor;

# constructor in base class only

sub new {
  my $pkg = shift;
  bless {}, $pkg;
}

# init, process, finish in subclasses

1;
[download]

Processor/SomeSubClass.pm

package Processor::SomeSubClass;

@ISA = ( Processor );

sub init {
  my $self = shift;
  # do something
}

# should be called process_line
# this one upcases it
sub process {
  my $self = shift;
  my $line = shift;
  return uc( $line );
}

sub finish {
  my $self = shift;
  # do something
}

1;
[download]

The script that runs it:

#!/usr/bin/perl

use Processor;
use Processor::SomeSubClass;

my $p = Processor::SomeSubClass->new();

$p->init;
while (<>) {
  print $p->process( $_ );
}
$p->finish;
[download]

I'm not totally sure if this is what you intended - init and finish coming before and after processing all the lines for example - but it should get you going if you havent't done it before.

Note that my examlpe does not store any of the data in the object - again, because its hard to see what problem you are going to be solving.

qq

qq,

Thanks for taking to time to provide that framework. That is what I was looking for to my overall design question. The one other question I have is about self determination of all the available processors. I planned on doing something similar to the following code, but I need to determine the base class versus just matching on the name of the object:

    foreach $symname (sort keys %main::) {
        #print "$_\n" if /^ybcp/;
        if ( $symname =~ /^ybcp/ ) {
            local *sym = $main::{$symname};
            $$sym->init();
            #print "\$$symname\n" if defined $sym;
        }
    }
[download]

With loops like this in my driver script, I should be able to simply add a new use statement for new processors.

Also... Just to wrap up my thoughts on my original issue. I was confused by my Perl book's explanation of the Exporter implementation. I thought it was necessary to add methods to the Exporter to make them accessible, but I now realize that it meant accessible without the module:: syntax.

If you want to loop over a list of subclassed processors, you probably want something like:

use Processor;
use Processor::SomeSubClass;
use Processor::AnotherSubClass;

foreach ( qw( SomeSubClass AnotherSubClass ) ) {
 my $pkg = "Processor::$_"; 
 my $processor = $pkg->new();
 $processor->init();
  # do something with $processor
}
[download]

Damien Conway's book is very good on OO perl, although he skips fast past some of the simple stuff.

qq

Implement them as objects. For one, you don't have the namespace collision problems. Plus, you can now have filters inherit from each other, which becomes really neat.