Aspect::Advice::Before(3pm) User Contributed Perl Documentation Aspect::Advice::Before(3pm)NAME
Aspect::Advice::Before - Execute code before a function is called
SYNOPSIS
use Aspect;
before {
# Trace all calls to your module
print STDERR "Called my function " . $_->sub_name . "
";
# Shortcut calls to foo() to always be true
if ( $_->short_name eq 'foo' ) {
return $_->return_value(1);
}
# Add an extra flag to bar() but call as normal
if ( $_->short_name eq 'bar' ) {
$_->args( $_->args, 'flag' );
}
} call qr/^ MyModule::w+ $/
DESCRIPTION
The "before" advice type is used to execute advice code prior to entry into a target function. It is implemented by Aspect::Advice::Before.
As well as creating side effects that run before the main code, the "before" advice type is particularly useful for changing parameters or
shortcutting calls to functions entirely and replacing the value they would normally return with a different value.
Please note that the "highest" pointcut (Aspect::Pointcut::Highest) is incompatible with "before". Creating a "before" advice with a
pointcut tree that contains a "highest" pointcut will result in an exception.
If speed is important to your program then "before" is particular interesting as the "before" implementation is the only one that can take
advantage of tail calls via Perl's "goto" function, where the rest of the advice types need the more costly Sub::Uplevel to keep caller()
returning correctly.
AUTHORS
Adam Kennedy <adamk@cpan.org>
COPYRIGHT AND LICENSE
Copyright 2010 Adam Kennedy.
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
perl v5.14.2 2012-02-01 Aspect::Advice::Before(3pm)
Check Out this Related Man Page
Aspect::Modular(3pm) User Contributed Perl Documentation Aspect::Modular(3pm)NAME
Aspect::Modular - First generation base class for reusable aspects
SYNOPSIS
# Subclassing to create a reusable aspect
package Aspect::Library::ConstructorTracer;
use strict;
use base 'Aspect::Modular';
use Aspect::Advice::After ();
sub get_advice {
my $self = shift;
my $pointcut = shift;
return Aspect::Advice::After->new(
lexical => $self->lexical,
pointcut => $pointcut,
code => sub {
print 'Created object: ' . shift->return_value . "
";
},
);
}
# Using the new aspect
package main;
use Aspect;
# Print message when constructing new Person
aspect ConstructorTracer => call 'Person::new';
DESCRIPTION
All reusable aspect inherit from this class.
Such aspects are created in user code, using the "aspect()" sub exported by Aspect. You call "aspect()" with the class name of the reusable
aspect (it must exist in the package "Aspect::Library"), and any parameters (pointcuts, class names, code to run, etc.) the specific aspect
may require.
The Wormhole aspect, for example, expects 2 pointcut specs for the wormhole source and target, while the Profiler aspect expects a pointcut
object, to select the subs to be profiled.
You create a reusable aspect by subclassing this class, and providing one template method: "get_advice()". It is called with all the
parameters that were sent when user code created the aspect, and is expected to return Aspect::Advice object/s, that will be installed
while the reusable aspect is still in scope. If the "aspect()" sub is called in void context, the reusable aspect is installed until class
reloading or interpreter shutdown.
Typical things a reusable aspect may want to do:
o Install advice on pointcuts specified by the caller
o Push (vs. OOP pull) subs and base classes into classes specified by the caller
AUTHORS
Adam Kennedy <adamk@cpan.org>
Marcel Gruenauer <marcel@cpan.org>
Ran Eilam <eilara@cpan.org>
COPYRIGHT
Copyright 2001 by Marcel Gruenauer
Some parts copyright 2009 - 2012 Adam Kennedy.
This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
perl v5.14.2 2012-02-01 Aspect::Modular(3pm)