--- nfo/perl/libs/DesignPattern/Bridge.pm	2002/12/13 21:46:29	1.1
+++ nfo/perl/libs/DesignPattern/Bridge.pm	2003/02/09 16:22:51	1.6
@@ -1,7 +1,23 @@
 ## --------------------------------------------------------------------------------
-##  $Id: Bridge.pm,v 1.1 2002/12/13 21:46:29 joko Exp $
+##  $Id: Bridge.pm,v 1.6 2003/02/09 16:22:51 joko Exp $
 ## --------------------------------------------------------------------------------
 ##  $Log: Bridge.pm,v $
+##  Revision 1.6  2003/02/09 16:22:51  joko
+##  + pseudo constructor mechanism via options
+##
+##  Revision 1.5  2003/01/31 01:19:50  root
+##  + fixed: doesn't need Log::Dispatch any more, but uses it if available
+##
+##  Revision 1.4  2003/01/20 16:55:15  joko
+##  + sub mixinPackage
+##  + sub include
+##
+##  Revision 1.3  2002/12/16 19:57:12  joko
+##  + sub unload
+##
+##  Revision 1.2  2002/12/15 02:06:15  joko
+##  + feature to be able to specify module in non-perl-style when loading plugins: e.g. $process->load('Setup/Storage')
+##
 ##  Revision 1.1  2002/12/13 21:46:29  joko
 ##  + initial check-in
 ##
@@ -15,6 +31,8 @@
 
 use base qw( DesignPattern::Object );
 
+use Data::Dumper;
+
 ## ========   object inheritance   ========
 
 # TODO:
@@ -29,8 +47,9 @@
 #   - sub run
 
 # get logger instance
-my $logger = Log::Dispatch::Config->instance;
+my $logger = eval { Log::Dispatch::Config->instance; };
   
+my $meta;
 
 ## ========   object constructor   ========
   sub new {
@@ -38,7 +57,7 @@
     my $class = ref($invocant) || $invocant;
     my @args = ();
     @_ && (@args = @_);
-    $logger->debug( __PACKAGE__ . "->new(@args)" );
+    $logger->debug( __PACKAGE__ . "->new(@args)" ) if $logger;
     my $self = { @_ };
     #print "class: $class", "\n";
     bless $self, $class;
@@ -61,7 +80,7 @@
     my $method = $AUTOLOAD;
     $method =~ s/^.*:://;
   
-    $logger->debug( __PACKAGE__ . "->" . $method . "(@_)" . " (AUTOLOAD called, not dispatched)" );
+    $logger->debug( __PACKAGE__ . "->" . $method . "(@_)" . " (AUTOLOAD called, not dispatched)" ) if $logger;
 
     ## ->DESTROY would - if not declared - trigger an AUTOLOAD also
     return if $method =~ m/::DESTROY$/;
@@ -72,21 +91,51 @@
 ##    }
     
   }
-  
-  sub load {
 
+  sub _getPluginPackage {
     my $self = shift;
+    my $modulename_load = shift;
+
+    # substitute slashes through double double-colons to load modules perl-style
+    $modulename_load =~ s/\//::/g;
+    
+    # build full package name
     my $self_classname = ref $self;
+    my $package = $self_classname . '::' . $modulename_load;
+    return $package;
+  }
+  
+  sub load {
 
+    my $self = shift;
     my $modulename_load = shift;
+
+    my $options = shift;
+
+    my $self_modulename = ref $self;
+    my $package = $self->_getPluginPackage($modulename_load);
     
-    my $package = $self_classname . '::' . $modulename_load;
-    $logger->info( __PACKAGE__ . "->load: $package" );
+    if ($meta->{loaded}->{$package}) {
+      return 1;
+    }
+    
+    #$logger->info( __PACKAGE__ . "->load: $package" ) if $logger;
+    #$logger->info( __PACKAGE__ . "->load: $self_modulename" ) if $logger;
+    $logger->debug( $self_modulename . "->load: $package\t[via " . __PACKAGE__ . "]" ) if $logger;
 
     # this is the module testing phase - use mixin doesn't seem to propagate errors by default
     eval("use $package;");
     if ($@) {
-      $logger->error( __PACKAGE__ . "->load: $@" );
+      $meta->{loaded}->{$package} = 0;
+      # include caller information
+      my @caller = caller;
+      my $caller_msg = $caller[1] . ':' . $caller[2];
+      my $msg =  __PACKAGE__ . "->load: $@ ($caller_msg)";
+      if ($logger) {
+        $logger->error($msg);
+      } else {
+        print $msg, "\n";
+      }
     }
 
 #print "ref-1: ", ref $self, "\n";
@@ -97,17 +146,60 @@
 
     # V2:
     # switch into foreign package and mixin plugin-module
+    $self->mixinPackage($package);
+
+    if (my $method = $options->{method}) {
+      $self->$method();
+    }
+
+    return 1;
+    
+  }
+
+  # TODO: maybe refactor to DesignPattern::Object? what about the '$logger'?
+  sub mixinPackage {
+    my $self = shift;
+    my $package = shift;
+    # switch into foreign package and mixin plugin-module
+    my $self_classname = ref $self;
     eval("package $self_classname; use mixin '$package';");
     #eval("use mixin_all '$package';");
     if ($@) {
-      $logger->error( __PACKAGE__ . "->load: $@" );
+      $meta->{loaded}->{$package} = 0;
+      $logger->error( __PACKAGE__ . "->load: $@" ) if $logger;
+    } else {
+      $meta->{loaded}->{$package} = 1;
     }
+  }
+
+  sub unload {
+
+    my $self = shift;
+    my $modulename_unload = shift;
+
+    my $package = $self->_getPluginPackage($modulename_unload);
     
+    if ($meta->{loaded}->{$package}) {
+      $meta->{loaded}->{$package} = 0;
+      my $where = __PACKAGE__ . ':' . __LINE__;
+      $logger->debug( __PACKAGE__ . "->unload: FIXME: DESTROY object is not implemented at '$where'." ) if $logger;
+    }
+
   }
 
+
   sub boot {
     my $self = shift;
     $self->_abstract_function('boot');
   }
+  
+  sub include {
+    my $self = shift;
+    my $includefile = shift;
+    my $package = shift;
+    # TODO: do better error-detection here / prevent dies under all circumstances!
+    require $includefile;
+    $self->mixinPackage($package) if $package;
+  }
 
 1;