X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP%2FMethod.pm;h=f3ae077e211dbcb4934c9c2b56c0edb4586e019a;hb=16e960bd460d404b809a1e5c24ba77405643342b;hp=4de0cdfd2fdf74c7b6947489c1c490e89da726f0;hpb=45e9e2c34d673ebfa732054b7da6df7f2910a5ef;p=gitmo%2FClass-MOP.git

diff --git a/lib/Class/MOP/Method.pm b/lib/Class/MOP/Method.pm
index 4de0cdf..f3ae077 100644
--- a/lib/Class/MOP/Method.pm
+++ b/lib/Class/MOP/Method.pm
@@ -8,7 +8,7 @@ use Carp         'confess';
 use Scalar::Util 'reftype', 'blessed';
 use B            'svref_2object';
 
-our $VERSION = '0.02';
+our $VERSION = '0.03';
 
 # introspection
 
@@ -19,112 +19,191 @@ sub meta {
 
 # construction
 
-sub new { 
+sub wrap { 
     my $class = shift;
     my $code  = shift;
-    (reftype($code) && reftype($code) eq 'CODE')
-        || confess "You must supply a CODE reference to bless";
+    ('CODE' eq (reftype($code) || ''))
+        || confess "You must supply a CODE reference to bless, not (" . ($code || 'undef') . ")";
     bless $code => blessed($class) || $class;
 }
 
-{
-	my %MODIFIERS;
-	
-	sub wrap {
-		my $code = shift;
-		(blessed($code))
-			|| confess "Can only ask the package name of a blessed CODE";
-		my $modifier_table = { 
-			orig   => $code,
-			before => [],
-			after  => [],		
-			around => {
-				cache   => $code,
-				methods => [],
-			},
-		};
-		my $method = $code->new(sub {
-			$_->(@_) for @{$modifier_table->{before}};
+# informational
+
+sub package_name { 
+	my $code = shift;
+	(blessed($code))
+		|| confess "Can only ask the package name of a blessed CODE";
+	svref_2object($code)->GV->STASH->NAME;
+}
+
+sub name { 
+	my $code = shift;
+	(blessed($code))
+		|| confess "Can only ask the package name of a blessed CODE";	
+	svref_2object($code)->GV->NAME;
+}
+
+sub fully_qualified_name {
+	my $code = shift;
+	(blessed($code))
+		|| confess "Can only ask the package name of a blessed CODE";
+	$code->package_name . '::' . $code->name;		
+}
+
+package Class::MOP::Method::Wrapped;
+
+use strict;
+use warnings;
+
+use Carp         'confess';
+use Scalar::Util 'reftype', 'blessed';
+use Sub::Name    'subname';
+
+our $VERSION = '0.01';
+
+our @ISA = ('Class::MOP::Method');	
+
+# NOTE:
+# this ugly beast is the result of trying 
+# to micro optimize this as much as possible
+# while not completely loosing maintainability.
+# At this point it's "fast enough", after all
+# you can't get something for nothing :)
+my $_build_wrapped_method = sub {
+	my $modifier_table = shift;
+	my ($before, $after, $around) = (
+		$modifier_table->{before},
+		$modifier_table->{after},		
+		$modifier_table->{around},		
+	);
+	if (@$before && @$after) {
+		$modifier_table->{cache} = sub {
+			$_->(@_) for @{$before};
 			my @rval;
-			if (defined wantarray) {
-				@rval = $modifier_table->{around}->{cache}->(@_);
-			}
-			else {
-				$modifier_table->{around}->{cache}->(@_);
-			}
-			$_->(@_) for @{$modifier_table->{after}};			
+			((defined wantarray) ?
+				((wantarray) ? 
+					(@rval = $around->{cache}->(@_)) 
+					: 
+					($rval[0] = $around->{cache}->(@_)))
+				:
+				$around->{cache}->(@_));
+			$_->(@_) for @{$after};			
 			return unless defined wantarray;
 			return wantarray ? @rval : $rval[0];
-		});	
-		$MODIFIERS{$method} = $modifier_table;
-		$method;  
+		}		
 	}
-	
-	sub add_before_modifier {
-		my $code     = shift;
-		my $modifier = shift;
-		(exists $MODIFIERS{$code})
-			|| confess "You must first wrap your method before adding a modifier";		
-		(blessed($code))
-			|| confess "Can only ask the package name of a blessed CODE";
-	    (reftype($modifier) && reftype($modifier) eq 'CODE')
-	        || confess "You must supply a CODE reference for a modifier";			
-		unshift @{$MODIFIERS{$code}->{before}} => $modifier;
+	elsif (@$before && !@$after) {
+		$modifier_table->{cache} = sub {
+			$_->(@_) for @{$before};
+			return $around->{cache}->(@_);
+		}		
 	}
-	
-	sub add_after_modifier {
-		my $code     = shift;
-		my $modifier = shift;
-		(exists $MODIFIERS{$code})
-			|| confess "You must first wrap your method before adding a modifier";		
-		(blessed($code))
-			|| confess "Can only ask the package name of a blessed CODE";
-	    (reftype($modifier) && reftype($modifier) eq 'CODE')
-	        || confess "You must supply a CODE reference for a modifier";			
-		push @{$MODIFIERS{$code}->{after}} => $modifier;
+	elsif (@$after && !@$before) {
+		$modifier_table->{cache} = sub {
+			my @rval;
+			((defined wantarray) ?
+				((wantarray) ? 
+					(@rval = $around->{cache}->(@_)) 
+					: 
+					($rval[0] = $around->{cache}->(@_)))
+				:
+				$around->{cache}->(@_));
+			$_->(@_) for @{$after};			
+			return unless defined wantarray;
+			return wantarray ? @rval : $rval[0];
+		}		
 	}
-	
-	{
-		my $compile_around_method = sub {{
-	    	my $f1 = pop;
-	    	return $f1 unless @_;
-	    	my $f2 = pop;
-	    	push @_, sub { $f2->( $f1, @_ ) };
-			redo;
-		}};
-	
-		sub add_around_modifier {
-			my $code     = shift;
-			my $modifier = shift;
-			(exists $MODIFIERS{$code})
-				|| confess "You must first wrap your method before adding a modifier";		
-			(blessed($code))
-				|| confess "Can only ask the package name of a blessed CODE";
-		    (reftype($modifier) && reftype($modifier) eq 'CODE')
-		        || confess "You must supply a CODE reference for a modifier";			
-			unshift @{$MODIFIERS{$code}->{around}->{methods}} => $modifier;		
-			$MODIFIERS{$code}->{around}->{cache} = $compile_around_method->(
-				@{$MODIFIERS{$code}->{around}->{methods}},
-				$MODIFIERS{$code}->{orig}
-			);
-		}	
+	else {
+		$modifier_table->{cache} = $around->{cache};
 	}
+};
+
+my %MODIFIERS;
+
+sub wrap {
+	my $class = shift;
+	my $code  = shift;
+	(blessed($code) && $code->isa('Class::MOP::Method'))
+		|| confess "Can only wrap blessed CODE";
+	my $modifier_table = { 
+		cache  => undef,
+		orig   => $code,
+		before => [],
+		after  => [],		
+		around => {
+			cache   => $code,
+			methods => [],		
+		},
+	};
+	$_build_wrapped_method->($modifier_table);
+	my $method = $class->SUPER::wrap(sub { $modifier_table->{cache}->(@_) });	
+	$MODIFIERS{$method} = $modifier_table;
+	$method;  
 }
 
-# informational
+sub get_original_method {
+	my $code = shift; 
+    $MODIFIERS{$code}->{orig} 
+        if exists $MODIFIERS{$code};
+}
 
-sub package_name { 
-	my $code = shift;
+sub add_before_modifier {
+	my $code     = shift;
+	my $modifier = shift;
+	(exists $MODIFIERS{$code})
+		|| confess "You must first wrap your method before adding a modifier";		
 	(blessed($code))
 		|| confess "Can only ask the package name of a blessed CODE";
-	svref_2object($code)->GV->STASH->NAME;
+	('CODE' eq (reftype($code) || ''))
+        || confess "You must supply a CODE reference for a modifier";			
+	unshift @{$MODIFIERS{$code}->{before}} => $modifier;
+	$_build_wrapped_method->($MODIFIERS{$code});
 }
 
-sub name { 
-	my $code = shift;
+sub add_after_modifier {
+	my $code     = shift;
+	my $modifier = shift;
+	(exists $MODIFIERS{$code})
+		|| confess "You must first wrap your method before adding a modifier";		
 	(blessed($code))
-		|| confess "Can only ask the package name of a blessed CODE";	
-	svref_2object($code)->GV->NAME;
+		|| confess "Can only ask the package name of a blessed CODE";
+    ('CODE' eq (reftype($code) || ''))
+        || confess "You must supply a CODE reference for a modifier";			
+	push @{$MODIFIERS{$code}->{after}} => $modifier;
+	$_build_wrapped_method->($MODIFIERS{$code});	
+}
+
+{
+	# NOTE:
+	# this is another possible canidate for 
+	# optimization as well. There is an overhead
+	# associated with the currying that, if 
+	# eliminated might make around modifiers
+	# more manageable.
+	my $compile_around_method = sub {{
+    	my $f1 = pop;
+    	return $f1 unless @_;
+    	my $f2 = pop;
+    	push @_, sub { $f2->( $f1, @_ ) };
+		redo;
+	}};
+
+	sub add_around_modifier {
+		my $code     = shift;
+		my $modifier = shift;
+		(exists $MODIFIERS{$code})
+			|| confess "You must first wrap your method before adding a modifier";		
+		(blessed($code))
+			|| confess "Can only ask the package name of a blessed CODE";
+	    ('CODE' eq (reftype($code) || ''))
+	        || confess "You must supply a CODE reference for a modifier";			
+		unshift @{$MODIFIERS{$code}->{around}->{methods}} => $modifier;		
+		$MODIFIERS{$code}->{around}->{cache} = $compile_around_method->(
+			@{$MODIFIERS{$code}->{around}->{methods}},
+			$MODIFIERS{$code}->{orig}
+		);
+		$_build_wrapped_method->($MODIFIERS{$code});		
+	}	
 }
 
 1;
@@ -168,7 +247,7 @@ to this class.
 
 =over 4
 
-=item B<new (&code)>
+=item B<wrap (&code)>
 
 This simply blesses the C<&code> reference passed to it.
 
@@ -182,13 +261,35 @@ This simply blesses the C<&code> reference passed to it.
 
 =item B<package_name>
 
+=item B<fully_qualified_name>
+
 =back
 
-=head1 SEE ALSO
+=head1 Class::MOP::Method::Wrapped METHODS
 
-http://dirtsimple.org/2005/01/clos-style-method-combination-for.html
+=head2 Construction
 
-http://www.gigamonkeys.com/book/object-reorientation-generic-functions.html
+=over 4
+
+=item B<wrap (&code)>
+
+This simply blesses the C<&code> reference passed to it.
+
+=item B<get_original_method>
+
+=back
+
+=head2 Modifiers
+
+=over 4
+
+=item B<add_before_modifier ($code)>
+
+=item B<add_after_modifier ($code)>
+
+=item B<add_around_modifier ($code)>
+
+=back
 
 =head1 AUTHOR
 
@@ -203,4 +304,5 @@ L<http://www.iinteractive.com>
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself. 
 
-=cut
\ No newline at end of file
+=cut
+