package Obj;

sub new {
    my $class = shift;
    my $id = shift;
    return bless { id => $id }, $class;
}

sub method1 {
    my $self = shift;
    print "Object $self->{'id'}: Method 1\n";
}

sub method2 {
    my $self = shift;
    print "Object $self->{'id'}: Method 2\n";
}

package main;

use Hook::LexWrap;

wrap 'Obj::method1', pre => sub { print "PRE method1\n" }, post => sub
+ { print "POST method1\n\n" };
wrap 'Obj::method2', pre => sub { print "PRE method2\n" }, post => sub
+ { print "POST method2\n\n" };

my $object1 = new Obj(1);
my $object2 = new Obj(2);

$object1->method1;
$object1->method2;
$object2->method1;
$object2->method2;

## OUTPUT
PRE method1
Object 1: Method 1
POST method1

PRE method2
Object 1: Method 2
POST method2

PRE method1
Object 2: Method 1
POST method1

PRE method2
Object 2: Method 2
POST method2
[download]

Fantastic! That's exactly what I'm looking for! Thanks lostjimmy =)

FWIW I did actually get this code to work, but I'm not sure how safe/portable/full of holes it is:

*Obj::myFunkyLogHandler = \$myFunkyLogHandler;
*Obj::doSomething2 = \&Obj::doSomething;
*Obj::doSomething = sub {
  $myFunkyLogHandler->Log("Hello there!");
  my $ret_val = Obj::doSomething2( @_ );
  $myFunkyLogHandler->Log("Bye for now!");
  return $ret_val;
};
[download]

so I guess I was a little closer to what I wanted than I thought!

Like jettero says, your version is very portable, and should be safe for what you are using it for. It is essentially what LexWrap does, minus some additional features and error checking.

On the other hand, LexWrap is a pure perl module, so there's really no issue with just including it with your script if you're looking for a clean wrapping module to use.

I would guess this method is the most portable since you don't need to install anything from CPAN to get it to work and this works on most (if not all) perls. The sub-class and/or cpan methods are certainly cleaner and more readable, but this is definitely portable.

-Paul

CPAN is your friend. There are a number of modules available that automatically prepend or append standard code to a set of functions. There source code should give you some ideas about how to go about this. Better yet, download them and try them out yourself:

• Sub::WrapPackages wraps all subs in a package with pre/post processing.
• Attribute::Handlers lets you assign attributes to subs. The attributes can be mapped to routines that prepend or postpend code to a subroutine. Complex and quirky and prone to lots of redundant coding. Perl also has limited built-in support for defining custom subroutine attributes, but it doesn't work well for subroutine definition. See these these threads: Support for attributes:get in Attribute::Handlers? and its follow-up for more information if you are interested. A newer module Sub::Attribute claims to be a slimmed down version of AttributeHandlers. You might want to check that out too.
• Sub::Override subroutines and syntactic sugar for overriding individual functions
• Sub::Versive another modules for automatically prepending and appending code to subroutines
• Sub::Prepend provides simple support for prepending code to existing subs.

This is just for starters. There are several more: just search CPAN on the word "sub" to see what is out there.

Best, beth

Probably the 'cleanest' way to do this would be to sub-class the object's class, and a create a method that does the logging and calls the parent's method. Something like this:

package Sub::Object;
use base qw(Orig::Obj);

sub doSomething { 
  my $self = shift @_;

  $myFunkyLogMachine->Log("hi!");
  my $value =  $self->SUPER::doSomething(@_);
  $myFunkyLogMachine->Log("hi!");

  return $value;
}
[download]

Then you would just use Sub::Object in place of Orig::Obj and you'd get the logging.

I was considering doing something like this, but it would require a lot of changes in the legacy code (script that's calling the object) - and I'm lazy =). I was hoping to just add a change to the beginning of the file (explicitly to the symbol table) and have the results, without going in and changing too much code.

Not a large number of changes... perl -pi -e 's/Orig::Obj/Sub::Object/g' should do it. ;)

But it looks like there are simpler ways.