Perl: Dynamic module loading, object inheritance and "common helper files"

Question

In a nutshell I try to model a network topology using objects for every instance in the network. Additionally I got a top-level manager class responsible for, well, managing these objects and performing integrity checks. The filestructure looks like this (I left out most of the object-files as they are all structured pretty equal):

Manager.pm
Constants.pm
Classes/
  +- Machine.pm
  +- Node.pm
  +- Object.pm
  +- Switch.pm

Coming from quite a few years in OOP, I'm a fan of code reuse etc. so I set up inheritance between thos objects, the inheritance tree (in this example) looks like this:

Switch  -+-> Node -+-> Object
Machine -+

All those objects are structured like this:

package Switch;
use parent qw(Node);

sub buildFromXML {
  ...
}
sub new {
  ...
}

# additonal methods

Now the interesting part:

Question 1

How can I ensure correct loading of all those objects without typing out the names statically? The underlying problem is: If I just require "$_" foreach glob("./Classes/*"); I get many "Subroutine new redefined at" errors. I also played around with use parent qw(-norequire Object), Module::Find and some other @INC modifications in various combinations, to make it short: It didn't work. Currently I'm statically importing all used classes, they auto-import their parent classes.
So basically what I'm asking: What is the (perl-)correct way of doing this?
And advanced: It would be very helpful to be able to create a more complex folder structure (as there will be quite a few objects) and still have inheritance + "autoloading"

Question 2 - SOLVED

How can I "share my imports"? I use several libraries (my own, containing some helper functions, LibXML, Scalar::Util, etc.) and I want to share them amongst my objects. (The reasoning behind that is, I may need to add another common library to all objects and chances are high that there will be well above 100 objects - no fun editing all of them manually and doing that with a regex / script would theoretically work but that doesn't seem like the cleanest solution available)
What I tried:

• import everything in Manager.pm -> Works inside the Manager package - gives me errors like "undefined subroutine &Switch::trace called"
• Create a include.pl file and do/require/use it inside every object - gives me the same errors.
• Some more stuff I sadly don't remember

include.pl basically would look like that:

use lib_perl;
use Scalar::Util qw(blessed);
use XML::LibXML;
use Data::Dumper;
use Error::TryCatch;
...

Again I ask: What's the correct way to do it? Am I using the right approach and just failing at the execution or should I change my structure completely?
It doesn't matter that much why my current code doesn't work that well, providing a correct, clean approach for those problems would be enough by far :)

EDIT: Totally forgot perl version -_- Sidenote: I can't upgrade perl, as I need libraries that are stuck with 5.8 :/

C:\> perl -version
This is perl, v5.8.8 built for MSWin32-x86-multi-thread
(with 50 registered patches, see perl -V for more detail)

Copyright 1987-2006, Larry Wall

Binary build 820 [274739] provided by ActiveState http://www.ActiveState.com
Built Jan 23 2007 15:57:46

Answer 1

This is just a partial answer to question 2, sharing imports.

Loading a module (via use) does two things:

1. Compiling the module and installing the contents in the namespace hierarchy (which is shared). See perldoc -f require.
2. Calling the import sub on each loaded module. This loads some subs or constants etc. into the namespace of the caller. This is a process that the Exporter class largely hides from view. This part is important to use subs etc. without their full name, e.g. max instead of List::Util::max. See perldoc -f use.

Lets view following three modules: A, B and User.

{
   package A;
   use List::Util qw(max);
   # can use List::Util::max
   # can use max
}
{
   package User;
   # can use List::Util::max -> it is already loaded
   # cannot use max, this name is not defined in this namespace
}

Package B defines a sub load that loads a predefined list of modules and subs into the callers namespace:

{
   package B;
   sub load {
     my $package = (caller())[0]; # caller is a built-in, fetches package name

     eval qq{package $package;} . <<'FINIS' ;
       use List::Util qw(max);
       # add further modules here to load
       # you can place arbitrarily complex code in this eval string
       # to execute it in all modules that call this sub.
       # (e.g. testing and registering)
       # However, this is orthogonal to OOP.
FINIS

     if ($@) {
       # Do error handling
     }
   }
}

Inside the eval'd string, we temporarily switch into the callers package and then load the specified module. This means that the User package code now looks like this:

{
   package User;
   B::load();
   # can use List::Util::max
   # can use max
}

However, you have to make sure the load sub is already loaded itself. use B if in doubt. It might be best to execute B::load() in the BEGIN phase, before the rest of the module is compiled:

{
  package User;
  BEGIN {use B; B::load()}
  # ...
}

is equivalent to

{
  package User;
  use B;
  use List::Util qw(max);
  # ...
}

TIMTOWTDI. Although I find evaling code quite messy and dangerous, it is the way I'd pursue in this scenario (rather than doing files, which is similar but has different side effects). Manually messing with typeglobs in the package namespace is hell in comparision, and copy-pasting a list of module names is like going back to the days when there wasn't even C's preprocessor.

---

Edit: Import::Into

… is a CPAN module providing this functionality via an interesting method interface. Using this module, we would redefine our B package the following way:

{
  package B;
  use List::Util;   # you have to 'use' or 'require' this first, before using 'load'.
  use Import::Into; # has to be installed from CPAN first
  sub load {
    my $package = caller;
    List::Util->import::into($package, qw(max));
    # should work too: strict->import::into($package);
    # ...
  }
}

This module hides all the dirty work (evaling) from view and does method call resolution gymnastics to allow importing pragmas into other namespaces.