The usual way to have several implementations of a function is to place them in a package namespace. If the modules furnish an object constructor, calling the runonce() method will automatically select the correct one.

To call a non-method runonce() from a package, use the fully-qualified name,

Package::Name::runonce();
[download]

for (keys %INC) {
    s!/!::!g;
    s/\.pm$//;
    eval { $_::runonce() };
}
[download]

Thanks. This looks promising. At the moment I have two subdirectories where these .pm files are: Main and Addins. What would need to be changed to use only these two subdirectories. Not the root driectory where the main script is located, or the perl root, only the two subdirectories?

At the top of the loop, the line,

    next unless m/^Main|Addins/;
[download]

will restrict attention to those two top level namespaces.

After Compline,
Zaxo

Depending on how much interaction you want and what plug-ins / add-ins you want and provide, either Module::Pluggable, possibly together with NEXT or a really simple mixin-based approach might work for you. The following code shows how several files can create code in the same namespace:

package AddIns;
use strict;

our %functions;
our $AUTOLOAD;

sub register {
  my ($class,$key, $sub) = @_;
  $functions{$key} ||= [];
  push @{ $functions{$key} }, $sub;
};

sub AUTOLOAD {
  my (@args) = @_;
  $AUTOLOAD =~ m!.*::([^:]+)$!
    or die "Strange subroutine '$AUTOLOAD' called.";
  my $key = $1;
  die "Unknown slot '$key' called"
    unless exists $functions{$key};
  for my $sub (@{ $functions{$key} }) {
    eval { $sub->(@args); };
    if ($@) {
      warn "Error while calling slot '$key' : $@";
    };
  };
};

package AddIn::First;
AddIn->register('runonce', \&runonce);

sub runonce { print "myfirstaddin" };

package AddIn::Second;
AddIn->register('runonce', \&runonce);

sub runonce { print "mysecondaddin" };

package main;

AddIn->runonce;

# All of this is untested though
[download]

You could walk the symbol table, but it'd be less dicey (i.e. you can't guarantee 100% that J Random Module's runonce really is your runonce) to have the modules call a registration routine if they want something run whenever (something along the lines of use MyRegistry qw( register ); register( 'Sompackage::runonce' );). You then walk the list that builds calling the subs named (or passed as coderefs).

You should use do (not use) to load files which don't use package (and they are typically named .pl, not .pm). use (and require) sometimes does nothing, which would be undesireable here.

Anyway, the following might be the simplest answer:

use strict;
use warnings;

use myfirstaddin  ();
use mysecondaddin ();

if (defined $ARGV[0] && $ARGV[0] eq 'second'} {
   mysecondaddin->import('runonce');
} else {
   myfirstaddin->import('runonce');
}

print "hello world";
runonce();
myfirstaddin::runonce();
mysecondaddin::runonce();
[download]

# myfirstaddin.pm

package myfirstaddin;

BEGIN {
   require Exporter;
   our @ISA       = qw( Exporter );
   our @EXPORT_OK = qw( runonce  );
}

# Other "use" statements go here.

sub runonce { print "This is file myfirstaddin."; }

1;
[download]

# mysecondaddin.pm

package mysecondaddin;

BEGIN {
   require Exporter;
   our @ISA       = qw( Exporter );
   our @EXPORT_OK = qw( runonce  );
}

# Other "use" statements go here.

sub runonce { print "This is file mysecondaddin."; }

1;
[download]

myfistadin::runonce();

mysecondadin::runonce();
[download]

#!/usr/bin/perl -w

use strict;

package test1;

sub runonce
{
print "hello";
}

1;
[download]

Thanks again Zaxo,
I ran a test using this, however, the $eval fails on me (in a browser I get Error 500)...

I use logging in the scripting to catch errors as well as MySQL calls (and anything else I choose to log). The log shows the following when the script is executed:

Sep 26, 2005 (10:49:52) : ERROR SITUATION: Interface Crash, error message:
syntax error at Main/Menu.pm line 101, near "$_::runonce(" Compilation failed in require at d:\PROGRA~1\APACHE~1\apache\cgi-bin\intern2.cgi line 31.

In the file Main/Menu.pm I have your code as:


sub sub_menus {
  for (keys %INC) {
    next unless m/^Main|Addins/;
    s!/!::!g;
    s/\.pm$//;
    #print "<font face=\"Arial\" size=\"2\">$_<br></font>\n";
    eval { $_::runonce() };
  }
}
[download]

The function, runonce (sub runonce), is available in exactly one file. Perhaps I shouldn't use sub, rather someother addressing scheme that I'm unawear of?

If I comment out the eval line and use the print line, execution runs clean (with the exception of runonce not running).

I assume the problem lye with the logging I have to catch problems and log them:


$SIG{__DIE__} = \&error_crash_trapper;
$SIG{__WARN__} = \&warn_crash_trapper;
[download]

Is there any other way to achieve this? Essentially I'm looking for simplicity and the use of a 'dummy' routine that doesn't rely on hard coded information which then allows for dynamic implementation.

This is not the cleanest approach, but it's one (untested) way:

package main;

use lib 'plugins';

main();

sub main
{
    load_plugins();
    init_plugins();
}

sub load_plugins
{
    for my $plugin (<plugins/*.pm>)
    {
        (my $package = $plugin) =~ s/\.pm//;
        require $plugin;
    }
}

my @plugins;

sub register_plugin
{
    my ($class, $plugin_subref) = @_
    push @plugins, $plugin_subref;
}

sub init_plugins
{
    $_->() for @plugins;
}

package ExamplePlugin;

sub import
{
    my $caller = caller();
    $caller->register_plugin( \&init );   
}

sub init
{
     # initialization code here
}

1;
[download]

for $plugin (<Main/*.pm>) {
    $plugin =~ s!/!::!g;
    $plugin =~ s/\.pm$//;
    use $plugin;
}
[download]

for $plugin (<Main/*.pm>) {
    $plugin =~ s!/!::!g;
    $plugin =~ s/\.pm$//;
    $plugin = "use $plugin\;";
    $plugin;
}
[download]