Profile of /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Meta/TypeCoercion.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For 01.HTTP.t
Run on Tue May 4 15:25:55 2010
Reported on Tue May 4 15:26:08 2010

File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Meta/TypeCoercion.pm
Statements Executed | 22
Statement Execution Time | 648µs

Subroutines — ordered by exclusive time
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
1 | 1 | 1 | 3.09ms | 55.1ms | Moose::Meta::TypeCoercion::::BEGIN@8Moose::Meta::TypeCoercion::BEGIN@8
1 | 1 | 1 | 46µs | 56µs | Moose::Meta::TypeCoercion::::BEGIN@4Moose::Meta::TypeCoercion::BEGIN@4
1 | 1 | 1 | 8µs | 23µs | Moose::Meta::TypeCoercion::::BEGIN@5Moose::Meta::TypeCoercion::BEGIN@5
1 | 1 | 1 | 6µs | 108µs | Moose::Meta::TypeCoercion::::BEGIN@6Moose::Meta::TypeCoercion::BEGIN@6
1 | 1 | 1 | 4µs | 4µs | Moose::Meta::TypeCoercion::::BEGIN@9Moose::Meta::TypeCoercion::BEGIN@9
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::__ANON__[:17]Moose::Meta::TypeCoercion::__ANON__[:17]
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::__ANON__[:67]Moose::Meta::TypeCoercion::__ANON__[:67]
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::add_type_coercionsMoose::Meta::TypeCoercion::add_type_coercions
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::coerceMoose::Meta::TypeCoercion::coerce
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::compile_type_coercionMoose::Meta::TypeCoercion::compile_type_coercion
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::has_coercion_for_typeMoose::Meta::TypeCoercion::has_coercion_for_type
0 | 0 | 0 | 0s | 0s | Moose::Meta::TypeCoercion::::newMoose::Meta::TypeCoercion::new

Call graph for these subroutines as a Graphviz dot language file.

Line | State ments | Time on line | Calls | Time in subs | Code
--- | --- | --- | --- | --- | ---
1 |  |  |  |  |
2 |  |  |  |  | package Moose::Meta::TypeCoercion;
3 |  |  |  |  |
4 | 3 | 42µs | 2 | 65µs | # spent 56µs (46+10) within Moose::Meta::TypeCoercion::BEGIN@4 which was called # once (46µs+10µs) by Moose::BEGIN@20 at line 4 use strict; # spent 56µs making 1 call to Moose::Meta::TypeCoercion::BEGIN@4 # spent 10µs making 1 call to strict::import
5 | 3 | 20µs | 2 | 38µs | # spent 23µs (8+15) within Moose::Meta::TypeCoercion::BEGIN@5 which was called # once (8µs+15µs) by Moose::BEGIN@20 at line 5 use warnings; # spent 23µs making 1 call to Moose::Meta::TypeCoercion::BEGIN@5 # spent 15µs making 1 call to warnings::import
6 | 3 | 24µs | 2 | 209µs | # spent 108µs (6+102) within Moose::Meta::TypeCoercion::BEGIN@6 which was called # once (6µs+102µs) by Moose::BEGIN@20 at line 6 use metaclass; # spent 108µs making 1 call to Moose::Meta::TypeCoercion::BEGIN@6 # spent 102µs making 1 call to metaclass::import
7 |  |  |  |  |
8 | 3 | 143µs | 1 | 55.1ms | # spent 55.1ms (3.09+52.1) within Moose::Meta::TypeCoercion::BEGIN@8 which was called # once (3.09ms+52.1ms) by Moose::BEGIN@20 at line 8 use Moose::Meta::Attribute; # spent 55.1ms making 1 call to Moose::Meta::TypeCoercion::BEGIN@8
9 | 3 | 371µs | 1 | 4µs | # spent 4µs within Moose::Meta::TypeCoercion::BEGIN@9 which was called # once (4µs+0s) by Moose::BEGIN@20 at line 9 use Moose::Util::TypeConstraints (); # spent 4µs making 1 call to Moose::Meta::TypeCoercion::BEGIN@9
10 |  |  |  |  |
11 | 1 | 500ns |  |  | our $VERSION = '0.98';
12 | 1 | 19µs |  |  | $VERSION = eval $VERSION;
13 | 1 | 400ns |  |  | our $AUTHORITY = 'cpan:STEVAN';
14 |  |  |  |  |
15 |  |  |  |  | __PACKAGE__->meta->add_attribute('type_coercion_map' => (
16 |  |  |  |  | reader => 'type_coercion_map',
17 |  |  |  |  | default => sub { [] }
18 | 1 | 6µs | 2 | 293µs | )); # spent 274µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 19µs making 1 call to Moose::Meta::TypeCoercion::meta
19 |  |  |  |  |
20 | 1 | 5µs | 3 | 2.50ms | __PACKAGE__->meta->add_attribute( # spent 1.56ms making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 927µs making 1 call to Moose::Meta::Attribute::new # spent 11µs making 1 call to Moose::Meta::TypeCoercion::meta
21 |  |  |  |  | Moose::Meta::Attribute->new('type_constraint' => (
22 |  |  |  |  | reader => 'type_constraint',
23 |  |  |  |  | weak_ref => 1
24 |  |  |  |  | ))
25 |  |  |  |  | );
26 |  |  |  |  |
27 |  |  |  |  | # private accessor
28 | 1 | 3µs | 2 | 284µs | __PACKAGE__->meta->add_attribute('compiled_type_coercion' => ( # spent 273µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 11µs making 1 call to Moose::Meta::TypeCoercion::meta
29 |  |  |  |  | accessor => '_compiled_type_coercion'
30 |  |  |  |  | ));
31 |  |  |  |  |
32 |  |  |  |  | sub new {
33 |  |  |  |  | my $class = shift;
34 |  |  |  |  | my $self = Class::MOP::class_of($class)->new_object(@_);
35 |  |  |  |  | $self->compile_type_coercion;
36 |  |  |  |  | return $self;
37 |  |  |  |  | }
38 |  |  |  |  |
39 |  |  |  |  | sub compile_type_coercion {
40 |  |  |  |  | my $self = shift;
41 |  |  |  |  | my @coercion_map = @{$self->type_coercion_map};
42 |  |  |  |  | my @coercions;
43 |  |  |  |  | while (@coercion_map) {
44 |  |  |  |  | my ($constraint_name, $action) = splice(@coercion_map, 0, 2);
45 |  |  |  |  | my $type_constraint = ref $constraint_name ? $constraint_name : Moose::Util::TypeConstraints::find_or_parse_type_constraint($constraint_name);
46 |  |  |  |  |
47 |  |  |  |  | unless ( defined $type_constraint ) {
48 |  |  |  |  | require Moose;
49 |  |  |  |  | Moose->throw_error("Could not find the type constraint ($constraint_name) to coerce from");
50 |  |  |  |  | }
51 |  |  |  |  |
52 |  |  |  |  | push @coercions => [
53 |  |  |  |  | $type_constraint->_compiled_type_constraint,
54 |  |  |  |  | $action
55 |  |  |  |  | ];
56 |  |  |  |  | }
57 |  |  |  |  | $self->_compiled_type_coercion(sub {
58 |  |  |  |  | my $thing = shift;
59 |  |  |  |  | foreach my $coercion (@coercions) {
60 |  |  |  |  | my ($constraint, $converter) = @$coercion;
61 |  |  |  |  | if ($constraint->($thing)) {
62 |  |  |  |  | local $_ = $thing;
63 |  |  |  |  | return $converter->($thing);
64 |  |  |  |  | }
65 |  |  |  |  | }
66 |  |  |  |  | return $thing;
67 |  |  |  |  | });
68 |  |  |  |  | }
69 |  |  |  |  |
70 |  |  |  |  | sub has_coercion_for_type {
71 |  |  |  |  | my ($self, $type_name) = @_;
72 |  |  |  |  | my %coercion_map = @{$self->type_coercion_map};
73 |  |  |  |  | exists $coercion_map{$type_name} ? 1 : 0;
74 |  |  |  |  | }
75 |  |  |  |  |
76 |  |  |  |  | sub add_type_coercions {
77 |  |  |  |  | my ($self, @new_coercion_map) = @_;
78 |  |  |  |  |
79 |  |  |  |  | my $coercion_map = $self->type_coercion_map;
80 |  |  |  |  | my %has_coercion = @$coercion_map;
81 |  |  |  |  |
82 |  |  |  |  | while (@new_coercion_map) {
83 |  |  |  |  | my ($constraint_name, $action) = splice(@new_coercion_map, 0, 2);
84 |  |  |  |  |
85 |  |  |  |  | if ( exists $has_coercion{$constraint_name} ) {
86 |  |  |  |  | require Moose;
87 |  |  |  |  | Moose->throw_error("A coercion action already exists for '$constraint_name'")
88 |  |  |  |  | }
89 |  |  |  |  |
90 |  |  |  |  | push @{$coercion_map} => ($constraint_name, $action);
91 |  |  |  |  | }
92 |  |  |  |  |
93 |  |  |  |  | # and re-compile ...
94 |  |  |  |  | $self->compile_type_coercion;
95 |  |  |  |  | }
96 |  |  |  |  |
97 |  |  |  |  | sub coerce { $_[0]->_compiled_type_coercion->($_[1]) }
98 |  |  |  |  |
99 |  |  |  |  |
100 | 1 | 14µs |  |  | 1;
101 |  |  |  |  |
102 |  |  |  |  | __END__
103 |  |  |  |  |
104 |  |  |  |  | =pod
105 |  |  |  |  |
106 |  |  |  |  | =head1 NAME
107 |  |  |  |  |
108 |  |  |  |  | Moose::Meta::TypeCoercion - The Moose Type Coercion metaclass
109 |  |  |  |  |
110 |  |  |  |  | =head1 DESCRIPTION
111 |  |  |  |  |
112 |  |  |  |  | A type coercion object is basically a mapping of one or more type
113 |  |  |  |  | constraints and the associated coercions subroutines.
114 |  |  |  |  |
115 |  |  |  |  | It's unlikely that you will need to instantiate an object of this
116 |  |  |  |  | class directly, as it's part of the deep internals of Moose.
117 |  |  |  |  |
118 |  |  |  |  | =head1 METHODS
119 |  |  |  |  |
120 |  |  |  |  | =over 4
121 |  |  |  |  |
122 |  |  |  |  | =item B<< Moose::Meta::TypeCoercion->new(%options) >>
123 |  |  |  |  |
124 |  |  |  |  | Creates a new type coercion object, based on the options provided.
125 |  |  |  |  |
126 |  |  |  |  | =over 8
127 |  |  |  |  |
128 |  |  |  |  | =item * type_constraint
129 |  |  |  |  |
130 |  |  |  |  | This is the L<Moose::Meta::TypeConstraint> object for the type that is
131 |  |  |  |  | being coerced I<to>.
132 |  |  |  |  |
133 |  |  |  |  | =back
134 |  |  |  |  |
135 |  |  |  |  | =item B<< $coercion->type_coercion_map >>
136 |  |  |  |  |
137 |  |  |  |  | This returns the map of type constraints to coercions as an array
138 |  |  |  |  | reference. The values of the array alternate between type names and
139 |  |  |  |  | subroutine references which implement the coercion.
140 |  |  |  |  |
141 |  |  |  |  | The value is an array reference because coercions are tried in the
142 |  |  |  |  | order they are added.
143 |  |  |  |  |
144 |  |  |  |  | =item B<< $coercion->type_constraint >>
145 |  |  |  |  |
146 |  |  |  |  | This returns the L<Moose::Meta::TypeConstraint> that was passed to the
147 |  |  |  |  | constructor.
148 |  |  |  |  |
149 |  |  |  |  | =item B<< $coercion->has_coercion_for_type($type_name) >>
150 |  |  |  |  |
151 |  |  |  |  | Returns true if the coercion can coerce the named type.
152 |  |  |  |  |
153 |  |  |  |  | =item B<< $coercion->add_type_coercions( $type_name => $sub, ... ) >>
154 |  |  |  |  |
155 |  |  |  |  | This method takes a list of type names and subroutine references. If
156 |  |  |  |  | the coercion already has a mapping for a given type, it throws an
157 |  |  |  |  | exception.
158 |  |  |  |  |
159 |  |  |  |  | Coercions are actually
160 |  |  |  |  |
161 |  |  |  |  | =item B<< $coercion->coerce($value) >>
162 |  |  |  |  |
163 |  |  |  |  | This method takes a value and applies the first valid coercion it
164 |  |  |  |  | finds.
165 |  |  |  |  |
166 |  |  |  |  | This means that if the value could belong to more than type in the
167 |  |  |  |  | coercion object, the first coercion added is used.
168 |  |  |  |  |
169 |  |  |  |  | =item B<< Moose::Meta::TypeCoercion->meta >>
170 |  |  |  |  |
171 |  |  |  |  | This will return a L<Class::MOP::Class> instance for this class.
172 |  |  |  |  |
173 |  |  |  |  | =back
174 |  |  |  |  |
175 |  |  |  |  | =head1 BUGS
176 |  |  |  |  |
177 |  |  |  |  | See L<Moose/BUGS> for details on reporting bugs.
178 |  |  |  |  |
179 |  |  |  |  | =head1 AUTHOR
180 |  |  |  |  |
181 |  |  |  |  | Stevan Little E<lt>stevan@iinteractive.comE<gt>
182 |  |  |  |  |
183 |  |  |  |  | =head1 COPYRIGHT AND LICENSE
184 |  |  |  |  |
185 |  |  |  |  | Copyright 2006-2010 by Infinity Interactive, Inc.
186 |  |  |  |  |
187 |  |  |  |  | L<http://www.iinteractive.com>
188 |  |  |  |  |
189 |  |  |  |  | This library is free software; you can redistribute it and/or modify
190 |  |  |  |  | it under the same terms as Perl itself.
191 |  |  |  |  |
192 |  |  |  |  | =cut