package Foo::Bar;
sub import {
    for (@_) {
        $Foo::Logging = 0 && next if $_ eq 'noLog';
        $Foo::MyThing = 1 && next if $_ eq 'myThing';
    }
}
[download]

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

I like that. The only problem that I see is that the base class also has functions that it exports and, under certain circumstances, will AUTOLOAD functions that don't exist, but which the client requests be exported. To get around that, I think I would need to trap those functions that I need, set the globals, and remove those functions from the import list. What do you think about the following (also untested :) code?

package Foo::Bar;
sub import {
    my %handlers = (
        DEFAULT_XFR => \&set_xfr,
        NO_LOG      => \&disable_logging
    );

    my @args;
    for my $i ( 1 .. $#_ ) {
        push(@args, [ $_[$i], $i ]), next if $_[$i] eq 'DEFAULT_XFR';
        push(@args, [ $_[$i], $i ]), next if $_[$i] eq 'NO_LOG';
    }
    # two loops because we don't want to splice @_ while looping over 
+it
    foreach my $arg ( @args ) {
        if ( exists $handlers( $arg->[0] ) ) {
            $handlers( $arg->[0] )->( $arg->[1], @_ );
        }
    }
    Foo::Bar->export_to_level( 1, @_ );
}

sub set_xfr {
    my $index = shift;
    if ( defined $_[$index + 1]  and $_[$index + 1] =~ /^([A-Z]\d{4,5}
+)$/ ) {
        $Foo::DEFAULT_XFR = $1;
        splice @_, $index, 2;
    } else {
        $Foo::DEFAULT_XFR = 'H00293';
        splice @_, $index, 1;
    }
} 

sub disable_logging {
    # same concept;
}
[download]

Cheers,
Ovid

Update: I'd also need to set a flag to see if the module was required instead of used. A require won't call the import() method, thus necessitating that the INIT() function still remain as a fall-back (and it would only fire if the import wasn't called).

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

I have found the export_to_level function in Exporter to be unmaintained and unreliable. Its error handling in particular leaves something to be desired due to poor maintainance and bad misunderstandings about the internals of Carp that it is messing around with.

I would therefore recommend using:

goto &Exporter::import;
[download]

rather than using export_to_level. Yeah, it is a hack. But it is a hack that works reliably.

That would be a lot cleaner, but there are no such methods and any code that I produce can't rely on them, due to backwards-compatibility requirements. Sigh... Even if those methods werre available, my constructor may never get called as the the methods can be used as functions.

I'm seeing some issues with dragonchild's solution, but it certainly seems like the only workable prospect (and it's pretty cool, too).

Cheers,
Ovid

Update: Hmm... or I could create the mutators myself and add them to Foo's symbol table.

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

Ick. I don't mean this as an insult (I'm sure it was nothing but a wild idea), but that's a pretty Microsoftian way of thinking, with Foo offering a modified interface when Bar is loaded (for some reason it makes me think of the MSOffice installers upgrading half your OS behind your back). Also you gain nothing because to modify Foo, Bar still has to know far too much about it.

So I suggest you rather not go there :)

Things popping up from my thought pool:

• Do your glob setting in a BEGIN block (that'll settle the load time requirement, methinks).
• If import is tied up you can hook the lesser known export_fail. For instance, from Carp.pm:
  

  @EXPORT_FAIL = qw(verbose);    # hook to enable verbose mode
  # if the caller specifies verbose usage 
  #("perl -MCarp=verbose script.pl")
  # then the following method will be called 
  # by the Exporter which knows
  # to do this thanks to @EXPORT_FAIL, above.  
  #$_[1] will contain the word
  # 'verbose'.
  sub export_fail {
      shift;
      $Verbose = shift if $_[0] eq 'verbose';
      return @_;
  }
  [download]

• I would also override the set_globals method - but that may be voided by other specs, I dunno.
• The author of the base class should 'use strict' ;)