X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP%2FMethod%2FWrapped.pm;h=3c0201790bbe647571468cfd75b8e1005e4eecc7;hb=07dca7e3186d90e9e7438b90c986c6508c785ccf;hp=ba1451bc8d15fc2d1177f20a9ebc0940833756c1;hpb=c23184fc39306590f9e481d76c199020a638bb28;p=gitmo%2FClass-MOP.git

diff --git a/lib/Class/MOP/Method/Wrapped.pm b/lib/Class/MOP/Method/Wrapped.pm
index ba1451b..3c02017 100644
--- a/lib/Class/MOP/Method/Wrapped.pm
+++ b/lib/Class/MOP/Method/Wrapped.pm
@@ -11,10 +11,10 @@ use Sub::Name    'subname';
 our $VERSION   = '0.02';
 our $AUTHORITY = 'cpan:STEVAN';
 
-use base 'Class::MOP::Method';	
+use base 'Class::MOP::Method';
 
 # NOTE:
-# this ugly beast is the result of trying 
+# 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
@@ -23,45 +23,45 @@ my $_build_wrapped_method = sub {
 	my $modifier_table = shift;
 	my ($before, $after, $around) = (
 		$modifier_table->{before},
-		$modifier_table->{after},		
-		$modifier_table->{around},		
+		$modifier_table->{after},
+		$modifier_table->{around},
 	);
 	if (@$before && @$after) {
 		$modifier_table->{cache} = sub {
 			$_->(@_) for @{$before};
 			my @rval;
 			((defined wantarray) ?
-				((wantarray) ? 
-					(@rval = $around->{cache}->(@_)) 
-					: 
+				((wantarray) ?
+					(@rval = $around->{cache}->(@_))
+					:
 					($rval[0] = $around->{cache}->(@_)))
 				:
 				$around->{cache}->(@_));
-			$_->(@_) for @{$after};			
+			$_->(@_) for @{$after};
 			return unless defined wantarray;
 			return wantarray ? @rval : $rval[0];
-		}		
+		}
 	}
 	elsif (@$before && !@$after) {
 		$modifier_table->{cache} = sub {
 			$_->(@_) for @{$before};
 			return $around->{cache}->(@_);
-		}		
+		}
 	}
 	elsif (@$after && !@$before) {
 		$modifier_table->{cache} = sub {
 			my @rval;
 			((defined wantarray) ?
-				((wantarray) ? 
-					(@rval = $around->{cache}->(@_)) 
-					: 
+				((wantarray) ?
+					(@rval = $around->{cache}->(@_))
+					:
 					($rval[0] = $around->{cache}->(@_)))
 				:
 				$around->{cache}->(@_));
-			$_->(@_) for @{$after};			
+			$_->(@_) for @{$after};
 			return unless defined wantarray;
 			return wantarray ? @rval : $rval[0];
-		}		
+		}
 	}
 	else {
 		$modifier_table->{cache} = $around->{cache};
@@ -72,25 +72,25 @@ sub wrap {
 	my $class = shift;
 	my $code  = shift;
 	(blessed($code) && $code->isa('Class::MOP::Method'))
-		|| confess "Can only wrap blessed CODE";	
-	my $modifier_table = { 
+		|| confess "Can only wrap blessed CODE";
+	my $modifier_table = {
 		cache  => undef,
 		orig   => $code,
 		before => [],
-		after  => [],		
+		after  => [],
 		around => {
 			cache   => $code->body,
-			methods => [],		
+			methods => [],
 		},
 	};
 	$_build_wrapped_method->($modifier_table);
-	my $method = $class->SUPER::wrap(sub { $modifier_table->{cache}->(@_) });	
+	my $method = $class->SUPER::wrap(sub { $modifier_table->{cache}->(@_) });
 	$method->{'%!modifier_table'} = $modifier_table;
-	$method;  
+	$method;
 }
 
 sub get_original_method {
-	my $code = shift; 
+	my $code = shift;
     $code->{'%!modifier_table'}->{orig};
 }
 
@@ -105,14 +105,14 @@ sub add_after_modifier {
 	my $code     = shift;
 	my $modifier = shift;
 	push @{$code->{'%!modifier_table'}->{after}} => $modifier;
-	$_build_wrapped_method->($code->{'%!modifier_table'});	
+	$_build_wrapped_method->($code->{'%!modifier_table'});
 }
 
 {
 	# NOTE:
-	# this is another possible canidate for 
+	# this is another possible candidate for
 	# optimization as well. There is an overhead
-	# associated with the currying that, if 
+	# associated with the currying that, if
 	# eliminated might make around modifiers
 	# more manageable.
 	my $compile_around_method = sub {{
@@ -126,13 +126,13 @@ sub add_after_modifier {
 	sub add_around_modifier {
 		my $code     = shift;
 		my $modifier = shift;
-		unshift @{$code->{'%!modifier_table'}->{around}->{methods}} => $modifier;		
+		unshift @{$code->{'%!modifier_table'}->{around}->{methods}} => $modifier;
 		$code->{'%!modifier_table'}->{around}->{cache} = $compile_around_method->(
 			@{$code->{'%!modifier_table'}->{around}->{methods}},
 			$code->{'%!modifier_table'}->{orig}->body
 		);
-		$_build_wrapped_method->($code->{'%!modifier_table'});		
-	}	
+		$_build_wrapped_method->($code->{'%!modifier_table'});
+	}
 }
 
 1;
@@ -141,7 +141,7 @@ __END__
 
 =pod
 
-=head1 NAME 
+=head1 NAME
 
 Class::MOP::Method::Wrapped - Method Meta Object to handle before/around/after modifiers
 
@@ -179,16 +179,14 @@ Class::MOP::Method::Wrapped - Method Meta Object to handle before/around/after m
 
 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 
-Yuval Kogman E<lt>nothingmuch@woobling.comE<gt>
-
 =head1 COPYRIGHT AND LICENSE
 
-Copyright 2006 by Infinity Interactive, Inc.
+Copyright 2006, 2007 by Infinity Interactive, Inc.
 
 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. 
+it under the same terms as Perl itself.
 
 =cut