← Index
NYTProf Performance Profile   « line view »
For flows_to_es.pl
  Run on Mon May 9 23:27:59 2016
Reported on Mon May 9 23:28:09 2016

Filename/usr/share/perl5/Role/Tiny.pm
StatementsExecuted 2125 statements in 7.44ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
19211.01ms2.31msRole::Tiny::::_install_methods Role::Tiny::_install_methods
3231795µs863µsRole::Tiny::::_concrete_methods_of Role::Tiny::_concrete_methods_of
21021441µs441µsRole::Tiny::::_getglob Role::Tiny::_getglob
411348µs727µsRole::Tiny::::_composite_info_for Role::Tiny::_composite_info_for
1411345µs7.59msRole::Tiny::::apply_roles_to_package Role::Tiny::apply_roles_to_package
1011254µs2.48msRole::Tiny::::apply_single_role_to_package Role::Tiny::apply_single_role_to_package
1911235µs362µsRole::Tiny::::_install_does Role::Tiny::_install_does
1921125µs151µsRole::Tiny::::_check_requires Role::Tiny::_check_requires
5121106µs106µsRole::Tiny::::_getstash Role::Tiny::_getstash
192172µs118µsRole::Tiny::::_load_module Role::Tiny::_load_module
192161µs61µsRole::Tiny::::_copy_applied_list Role::Tiny::_copy_applied_list
192158µs1.13msRole::Tiny::::_install_modifiers Role::Tiny::_install_modifiers
191146µs46µsRole::Tiny::::CORE:subst Role::Tiny::CORE:subst (opcode)
63235µs44µsRole::Tiny::::does_role Role::Tiny::does_role
101129µs3.40msRole::Tiny::::apply_role_to_package Role::Tiny::apply_role_to_package
141119µs19µsRole::Tiny::::role_application_steps Role::Tiny::role_application_steps
11113µs26µsRole::Tiny::::BEGIN@276 Role::Tiny::BEGIN@276
11112µs26µsRole::Tiny::::BEGIN@6 Role::Tiny::BEGIN@6
11111µs26µsRole::Tiny::::BEGIN@352 Role::Tiny::BEGIN@352
11110µs21µsRole::Tiny::::BEGIN@402 Role::Tiny::BEGIN@402
1118µs8µsRole::Tiny::::BEGIN@19 Role::Tiny::BEGIN@19
1118µs22µsRole::Tiny::::BEGIN@7 Role::Tiny::BEGIN@7
4116µs6µsRole::Tiny::::CORE:sort Role::Tiny::CORE:sort (opcode)
0000s0sRole::Tiny::::__ANON__[:385] Role::Tiny::__ANON__[:385]
0000s0sRole::Tiny::::__ANON__[:401] Role::Tiny::__ANON__[:401]
0000s0sRole::Tiny::::__ANON__[:56] Role::Tiny::__ANON__[:56]
0000s0sRole::Tiny::::__ANON__[:61] Role::Tiny::__ANON__[:61]
0000s0sRole::Tiny::::__ANON__[:65] Role::Tiny::__ANON__[:65]
0000s0sRole::Tiny::__GUARD__::::DESTROYRole::Tiny::__GUARD__::DESTROY
0000s0sRole::Tiny::::_composable_package_for Role::Tiny::_composable_package_for
0000s0sRole::Tiny::::_composite_name Role::Tiny::_composite_name
0000s0sRole::Tiny::::_install_single_modifier Role::Tiny::_install_single_modifier
0000s0sRole::Tiny::::apply_roles_to_object Role::Tiny::apply_roles_to_object
0000s0sRole::Tiny::::create_class_with_roles Role::Tiny::create_class_with_roles
0000s0sRole::Tiny::::import Role::Tiny::import
0000s0sRole::Tiny::::is_role Role::Tiny::is_role
0000s0sRole::Tiny::::methods_provided_by Role::Tiny::methods_provided_by
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1package Role::Tiny;
2
3210638µs
# spent 441µs within Role::Tiny::_getglob which was called 210 times, avg 2µs/call: # 202 times (427µs+0s) by Role::Tiny::_install_methods at line 353, avg 2µs/call # 8 times (14µs+0s) by Role::Tiny::_install_does at line 403, avg 2µs/call
sub _getglob { \*{$_[0]} }
451158µs
# spent 106µs within Role::Tiny::_getstash which was called 51 times, avg 2µs/call: # 32 times (69µs+0s) by Role::Tiny::_concrete_methods_of at line 315, avg 2µs/call # 19 times (37µs+0s) by Role::Tiny::_install_methods at line 342, avg 2µs/call
sub _getstash { \%{"$_[0]::"} }
5
6232µs240µs
# spent 26µs (12+14) within Role::Tiny::BEGIN@6 which was called: # once (12µs+14µs) by Moo::Role::BEGIN@5 at line 6
use strict;
# spent 26µs making 1 call to Role::Tiny::BEGIN@6 # spent 14µs making 1 call to strict::import
72122µs237µs
# spent 22µs (8+15) within Role::Tiny::BEGIN@7 which was called: # once (8µs+15µs) by Moo::Role::BEGIN@5 at line 7
use warnings FATAL => 'all';
# spent 22µs making 1 call to Role::Tiny::BEGIN@7 # spent 15µs making 1 call to warnings::import
8
91700nsour $VERSION = '1.003002'; # 1.3.2
10119µs$VERSION = eval $VERSION;
# spent 2µs executing statements in string eval
11
121300nsour %INFO;
131100nsour %APPLIED_TO;
141100nsour %COMPOSED;
151100nsour %COMPOSITE_INFO;
16
17# Module state workaround totally stolen from Zefram's Module::Runtime.
18
19
# spent 8µs within Role::Tiny::BEGIN@19 which was called: # once (8µs+0s) by Moo::Role::BEGIN@5 at line 21
BEGIN {
2019µs *_WORK_AROUND_BROKEN_MODULE_STATE = "$]" < 5.009 ? sub(){1} : sub(){0};
2111.76ms18µs}
# spent 8µs making 1 call to Role::Tiny::BEGIN@19
22
23sub Role::Tiny::__GUARD__::DESTROY {
24 delete $INC{$_[0]->[0]} if @{$_[0]};
25}
26
27
# spent 118µs (72+46) within Role::Tiny::_load_module which was called 19 times, avg 6µs/call: # 10 times (39µs+25µs) by Role::Tiny::apply_single_role_to_package at line 83, avg 6µs/call # 9 times (33µs+22µs) by Role::Tiny::_composite_info_for at line 249, avg 6µs/call
sub _load_module {
281989µs1946µs (my $proto = $_[0]) =~ s/::/\//g;
# spent 46µs making 19 calls to Role::Tiny::CORE:subst, avg 2µs/call
29196µs $proto .= '.pm';
301942µs return 1 if $INC{$proto};
31 # can't just ->can('can') because a sub-package Foo::Bar::Baz
32 # creates a 'Baz::' key in Foo::Bar's symbol table
33 return 1 if grep !/::$/, keys %{_getstash($_[0])||{}};
34 my $guard = _WORK_AROUND_BROKEN_MODULE_STATE
35 && bless([ $proto ], 'Role::Tiny::__GUARD__');
36 require $proto;
37 pop @$guard if _WORK_AROUND_BROKEN_MODULE_STATE;
38 return 1;
39}
40
41sub import {
42 my $target = caller;
43 my $me = shift;
44 strict->import;
45 warnings->import(FATAL => 'all');
46 return if $INFO{$target}; # already exported into this package
47 $INFO{$target}{is_role} = 1;
48 # get symbol table reference
49 my $stash = _getstash($target);
50 # install before/after/around subs
51 foreach my $type (qw(before after around)) {
52 *{_getglob "${target}::${type}"} = sub {
53 require Class::Method::Modifiers;
54 push @{$INFO{$target}{modifiers}||=[]}, [ $type => @_ ];
55 return;
56 };
57 }
58 *{_getglob "${target}::requires"} = sub {
59 push @{$INFO{$target}{requires}||=[]}, @_;
60 return;
61 };
62 *{_getglob "${target}::with"} = sub {
63 $me->apply_roles_to_package($target, @_);
64 return;
65 };
66 # grab all *non-constant* (stash slot is not a scalarref) subs present
67 # in the symbol table and store their refaddrs (no need to forcibly
68 # inflate constant subs into real subs) with a map to the coderefs in
69 # case of copying or re-use
70 my @not_methods = (map { *$_{CODE}||() } grep !ref($_), values %$stash);
71 @{$INFO{$target}{not_methods}={}}{@not_methods} = @not_methods;
72 # a role does itself
73 $APPLIED_TO{$target} = { $target => undef };
74}
75
76
# spent 19µs within Role::Tiny::role_application_steps which was called 14 times, avg 1µs/call: # 14 times (19µs+0s) by Moo::Role::role_application_steps at line 231 of Moo/Role.pm, avg 1µs/call
sub role_application_steps {
771437µs qw(_install_methods _check_requires _install_modifiers _copy_applied_list);
78}
79
80
# spent 2.48ms (254µs+2.22) within Role::Tiny::apply_single_role_to_package which was called 10 times, avg 248µs/call: # 10 times (254µs+2.22ms) by Moo::Role::apply_single_role_to_package at line 248 of Moo/Role.pm, avg 248µs/call
sub apply_single_role_to_package {
81106µs my ($me, $to, $role) = @_;
82
83108µs1064µs _load_module($role);
# spent 64µs making 10 calls to Role::Tiny::_load_module, avg 6µs/call
84
85102µs die "This is apply_role_to_package" if ref($to);
86105µs die "${role} is not a Role::Tiny" unless $INFO{$role};
87
881038µs1056µs foreach my $step ($me->role_application_steps) {
# spent 56µs making 10 calls to Moo::Role::role_application_steps, avg 6µs/call
8960123µs602.10ms $me->$step($to, $role);
# spent 1.32ms making 10 calls to Role::Tiny::_install_methods, avg 132µs/call # spent 512µs making 10 calls to Moo::Role::_handle_constructor, avg 51µs/call # spent 127µs making 10 calls to Moo::Role::_maybe_make_accessors, avg 13µs/call # spent 92µs making 10 calls to Role::Tiny::_check_requires, avg 9µs/call # spent 34µs making 10 calls to Role::Tiny::_copy_applied_list, avg 3µs/call # spent 22µs making 10 calls to Role::Tiny::_install_modifiers, avg 2µs/call
90 }
91}
92
93
# spent 61µs within Role::Tiny::_copy_applied_list which was called 19 times, avg 3µs/call: # 10 times (34µs+0s) by Role::Tiny::apply_single_role_to_package at line 89, avg 3µs/call # 9 times (27µs+0s) by Role::Tiny::apply_roles_to_package at line 238, avg 3µs/call
sub _copy_applied_list {
94197µs my ($me, $to, $role) = @_;
95 # copy our role list into the target's
961980µs @{$APPLIED_TO{$to}||={}}{keys %{$APPLIED_TO{$role}}} = ();
97}
98
99sub apply_roles_to_object {
100 my ($me, $object, @roles) = @_;
101 die "No roles supplied!" unless @roles;
102 my $class = ref($object);
103 bless($object, $me->create_class_with_roles($class, @roles));
104 $object;
105}
106
1071500nsmy $role_suffix = 'A000';
108sub _composite_name {
109 my ($me, $superclass, @roles) = @_;
110
111 my $new_name = join(
112 '__WITH__', $superclass, my $compose_name = join '__AND__', @roles
113 );
114
115 if (length($new_name) > 252) {
116 $new_name = $COMPOSED{abbrev}{$new_name}
117 ||= substr($new_name, 0, 250 - length $role_suffix).'__'.$role_suffix++;
118 }
119 return wantarray ? ($new_name, $compose_name) : $new_name;
120}
121
122sub create_class_with_roles {
123 my ($me, $superclass, @roles) = @_;
124
125 die "No roles supplied!" unless @roles;
126
127 _load_module($superclass);
128 {
129 my %seen;
130 $seen{$_}++ for @roles;
131 if (my @dupes = grep $seen{$_} > 1, @roles) {
132 die "Duplicated roles: ".join(', ', @dupes);
133 }
134 }
135
136 my ($new_name, $compose_name) = $me->_composite_name($superclass, @roles);
137
138 return $new_name if $COMPOSED{class}{$new_name};
139
140 foreach my $role (@roles) {
141 _load_module($role);
142 die "${role} is not a Role::Tiny" unless $INFO{$role};
143 }
144
145 if ($] >= 5.010) {
146 require mro;
147 } else {
148 require MRO::Compat;
149 }
150
151 my $composite_info = $me->_composite_info_for(@roles);
152 my %conflicts = %{$composite_info->{conflicts}};
153 if (keys %conflicts) {
154 my $fail =
155 join "\n",
156 map {
157 "Method name conflict for '$_' between roles "
158 ."'".join(' and ', sort values %{$conflicts{$_}})."'"
159 .", cannot apply these simultaneously to an object."
160 } keys %conflicts;
161 die $fail;
162 }
163
164 my @composable = map $me->_composable_package_for($_), reverse @roles;
165
166 # some methods may not exist in the role, but get generated by
167 # _composable_package_for (Moose accessors via Moo). filter out anything
168 # provided by the composable packages, excluding the subs we generated to
169 # make modifiers work.
170 my @requires = grep {
171 my $method = $_;
172 !grep $_->can($method) && !$COMPOSED{role}{$_}{modifiers_only}{$method},
173 @composable
174 } @{$composite_info->{requires}};
175
176 $me->_check_requires(
177 $superclass, $compose_name, \@requires
178 );
179
180 *{_getglob("${new_name}::ISA")} = [ @composable, $superclass ];
181
182 @{$APPLIED_TO{$new_name}||={}}{
183 map keys %{$APPLIED_TO{$_}}, @roles
184 } = ();
185
186 $COMPOSED{class}{$new_name} = 1;
187 return $new_name;
188}
189
190# preserved for compat, and apply_roles_to_package calls it to allow an
191# updated Role::Tiny to use a non-updated Moo::Role
192
1931028µs103.37ms
# spent 3.40ms (29µs+3.37) within Role::Tiny::apply_role_to_package which was called 10 times, avg 340µs/call: # 10 times (29µs+3.37ms) by Role::Tiny::apply_roles_to_package at line 198, avg 340µs/call
sub apply_role_to_package { shift->apply_single_role_to_package(@_) }
# spent 3.37ms making 10 calls to Moo::Role::apply_single_role_to_package, avg 337µs/call
194
195
# spent 7.59ms (345µs+7.24) within Role::Tiny::apply_roles_to_package which was called 14 times, avg 542µs/call: # 14 times (345µs+7.24ms) by Moo::Role::apply_roles_to_package at line 241 of Moo/Role.pm, avg 542µs/call
sub apply_roles_to_package {
1961414µs my ($me, $to, @roles) = @_;
197
1981440µs103.40ms return $me->apply_role_to_package($to, $roles[0]) if @roles == 1;
# spent 3.40ms making 10 calls to Role::Tiny::apply_role_to_package, avg 340µs/call
199
200415µs4727µs my %conflicts = %{$me->_composite_info_for(@roles)->{conflicts}};
# spent 727µs making 4 calls to Role::Tiny::_composite_info_for, avg 182µs/call
201419µs470µs delete $conflicts{$_} for keys %{ $me->_concrete_methods_of($to) };
# spent 70µs making 4 calls to Role::Tiny::_concrete_methods_of, avg 18µs/call
20242µs if (keys %conflicts) {
203 my $fail =
204 join "\n",
205 map {
206 "Due to a method name conflict between roles "
207 ."'".join(' and ', sort values %{$conflicts{$_}})."'"
208 .", the method '$_' must be implemented by '${to}'"
209 } keys %conflicts;
210 die $fail;
211 }
212
213 # the if guard here is essential since otherwise we accidentally create
214 # a $INFO for something that isn't a Role::Tiny (or Moo::Role) because
215 # autovivification hates us and wants us to die()
21642µs if ($INFO{$to}) {
217 delete $INFO{$to}{methods}; # reset since we're about to add methods
218 }
219
220 # backcompat: allow subclasses to use apply_single_role_to_package
221 # to apply changes. set a local var so ours does nothing.
2224500ns our %BACKCOMPAT_HACK;
223431µs49µs if($me ne __PACKAGE__
# spent 9µs making 4 calls to UNIVERSAL::can, avg 2µs/call
224 and exists $BACKCOMPAT_HACK{$me} ? $BACKCOMPAT_HACK{$me} :
225 $BACKCOMPAT_HACK{$me} =
226 $me->can('role_application_steps')
227 == \&role_application_steps
228 && $me->can('apply_single_role_to_package')
229 != \&apply_single_role_to_package
230 ) {
231 foreach my $role (@roles) {
232 $me->apply_single_role_to_package($to, $role);
233 }
234 }
235 else {
23647µs424µs foreach my $step ($me->role_application_steps) {
# spent 24µs making 4 calls to Moo::Role::role_application_steps, avg 6µs/call
2372416µs foreach my $role (@roles) {
23854117µs543.02ms $me->$step($to, $role);
# spent 1.11ms making 9 calls to Role::Tiny::_install_modifiers, avg 123µs/call # spent 991µs making 9 calls to Role::Tiny::_install_methods, avg 110µs/call # spent 772µs making 9 calls to Moo::Role::_handle_constructor, avg 86µs/call # spent 58µs making 9 calls to Role::Tiny::_check_requires, avg 6µs/call # spent 56µs making 9 calls to Moo::Role::_maybe_make_accessors, avg 6µs/call # spent 27µs making 9 calls to Role::Tiny::_copy_applied_list, avg 3µs/call
239 }
240 }
241 }
242419µs $APPLIED_TO{$to}{join('|',@roles)} = 1;
243}
244
245
# spent 727µs (348+380) within Role::Tiny::_composite_info_for which was called 4 times, avg 182µs/call: # 4 times (348µs+380µs) by Role::Tiny::apply_roles_to_package at line 200, avg 182µs/call
sub _composite_info_for {
24643µs my ($me, @roles) = @_;
247438µs46µs $COMPOSITE_INFO{join('|', sort @roles)} ||= do {
# spent 6µs making 4 calls to Role::Tiny::CORE:sort, avg 2µs/call
24843µs foreach my $role (@roles) {
249912µs954µs _load_module($role);
# spent 54µs making 9 calls to Role::Tiny::_load_module, avg 6µs/call
250 }
2514700ns my %methods;
25242µs foreach my $role (@roles) {
253925µs9319µs my $this_methods = $me->_concrete_methods_of($role);
# spent 319µs making 9 calls to Role::Tiny::_concrete_methods_of, avg 35µs/call
2549124µs $methods{$_}{$this_methods->{$_}} = $role for keys %$this_methods;
255 }
2564500ns my %requires;
257416µs @requires{map @{$INFO{$_}{requires}||[]}, @roles} = ();
258429µs delete $requires{$_} for keys %methods;
259480µs delete $methods{$_} for grep keys(%{$methods{$_}}) == 1, keys %methods;
26049µs +{ conflicts => \%methods, requires => [keys %requires] }
261 };
262}
263
264sub _composable_package_for {
265 my ($me, $role) = @_;
266 my $composed_name = 'Role::Tiny::_COMPOSABLE::'.$role;
267 return $composed_name if $COMPOSED{role}{$composed_name};
268 $me->_install_methods($composed_name, $role);
269 my $base_name = $composed_name.'::_BASE';
270 # force stash to exist so ->can doesn't complain
271 _getstash($base_name);
272 # Not using _getglob, since setting @ISA via the typeglob breaks
273 # inheritance on 5.10.0 if the stash has previously been accessed an
274 # then a method called on the class (in that order!), which
275 # ->_install_methods (with the help of ->_install_does) ends up doing.
2762632µs240µs
# spent 26µs (13+13) within Role::Tiny::BEGIN@276 which was called: # once (13µs+13µs) by Moo::Role::BEGIN@5 at line 276
{ no strict 'refs'; @{"${composed_name}::ISA"} = ( $base_name ); }
# spent 26µs making 1 call to Role::Tiny::BEGIN@276 # spent 13µs making 1 call to strict::unimport
277 my $modifiers = $INFO{$role}{modifiers}||[];
278 my @mod_base;
279 my @modifiers = grep !$composed_name->can($_),
280 do { my %h; @h{map @{$_}[1..$#$_-1], @$modifiers} = (); keys %h };
281 foreach my $modified (@modifiers) {
282 push @mod_base, "sub ${modified} { shift->next::method(\@_) }";
283 }
284 my $e;
285 {
286 local $@;
287 eval(my $code = join "\n", "package ${base_name};", @mod_base);
288 $e = "Evaling failed: $@\nTrying to eval:\n${code}" if $@;
289 }
290 die $e if $e;
291 $me->_install_modifiers($composed_name, $role);
292 $COMPOSED{role}{$composed_name} = {
293 modifiers_only => { map { $_ => 1 } @modifiers },
294 };
295 return $composed_name;
296}
297
298
# spent 151µs (125+25) within Role::Tiny::_check_requires which was called 19 times, avg 8µs/call: # 10 times (77µs+15µs) by Role::Tiny::apply_single_role_to_package at line 89, avg 9µs/call # 9 times (49µs+10µs) by Role::Tiny::apply_roles_to_package at line 238, avg 6µs/call
sub _check_requires {
2991910µs my ($me, $to, $name, $requires) = @_;
3001955µs return unless my @requires = @{$requires||$INFO{$name}{requires}||[]};
3019103µs1825µs if (my @requires_fail = grep !$to->can($_), @requires) {
# spent 25µs making 18 calls to UNIVERSAL::can, avg 1µs/call
302 # role -> role, add to requires, role -> class, error out
30312µs if (my $to_info = $INFO{$to}) {
304 push @{$to_info->{requires}||=[]}, @requires_fail;
305 } else {
306 die "Can't apply ${name} to ${to} - missing ".join(', ', @requires_fail);
307 }
308 }
309}
310
311
# spent 863µs (795+69) within Role::Tiny::_concrete_methods_of which was called 32 times, avg 27µs/call: # 19 times (432µs+42µs) by Role::Tiny::_install_methods at line 339, avg 25µs/call # 9 times (300µs+19µs) by Role::Tiny::_composite_info_for at line 253, avg 35µs/call # 4 times (63µs+7µs) by Role::Tiny::apply_roles_to_package at line 201, avg 18µs/call
sub _concrete_methods_of {
3123211µs my ($me, $role) = @_;
3133213µs my $info = $INFO{$role};
314 # grab role symbol table
3153229µs3269µs my $stash = _getstash($role);
# spent 69µs making 32 calls to Role::Tiny::_getstash, avg 2µs/call
316 # reverse so our keys become the values (captured coderefs) in case
317 # they got copied or re-used since
31832165µs my $not_methods = { reverse %{$info->{not_methods}||{}} };
319 $info->{methods} ||= +{
320 # grab all code entries that aren't in the not_methods list
321 map {
322373422µs my $code = *{$stash->{$_}}{CODE};
323341162µs ( ! $code or exists $not_methods->{$code} ) ? () : ($_ => $code)
324 } grep !ref($stash->{$_}), keys %$stash
325 };
326}
327
328sub methods_provided_by {
329 my ($me, $role) = @_;
330 die "${role} is not a Role::Tiny" unless my $info = $INFO{$role};
331 (keys %{$me->_concrete_methods_of($role)}, @{$info->{requires}||[]});
332}
333
334
# spent 2.31ms (1.01+1.30) within Role::Tiny::_install_methods which was called 19 times, avg 121µs/call: # 10 times (526µs+790µs) by Role::Tiny::apply_single_role_to_package at line 89, avg 132µs/call # 9 times (480µs+510µs) by Role::Tiny::apply_roles_to_package at line 238, avg 110µs/call
sub _install_methods {
335198µs my ($me, $to, $role) = @_;
336
337199µs my $info = $INFO{$role};
338
3391934µs19474µs my $methods = $me->_concrete_methods_of($role);
# spent 474µs making 19 calls to Role::Tiny::_concrete_methods_of, avg 25µs/call
340
341 # grab target symbol table
3421922µs1937µs my $stash = _getstash($to);
# spent 37µs making 19 calls to Role::Tiny::_getstash, avg 2µs/call
343
344 # determine already extant methods of target
345193µs my %has_methods;
346 @has_methods{grep
34719205µs +(ref($stash->{$_}) || *{$stash->{$_}}{CODE}),
348 keys %$stash
349 } = ();
350
3511961µs foreach my $i (grep !exists $has_methods{$_}, keys %$methods) {
3522419µs241µs
# spent 26µs (11+15) within Role::Tiny::BEGIN@352 which was called: # once (11µs+15µs) by Moo::Role::BEGIN@5 at line 352
no warnings 'once';
# spent 26µs making 1 call to Role::Tiny::BEGIN@352 # spent 15µs making 1 call to warnings::unimport
353202354µs202427µs *{_getglob "${to}::${i}"} = $methods->{$i};
# spent 427µs making 202 calls to Role::Tiny::_getglob, avg 2µs/call
354 }
355
3561984µs19362µs $me->_install_does($to);
# spent 362µs making 19 calls to Role::Tiny::_install_does, avg 19µs/call
357}
358
359
# spent 1.13ms (58µs+1.07) within Role::Tiny::_install_modifiers which was called 19 times, avg 60µs/call: # 10 times (22µs+0s) by Role::Tiny::apply_single_role_to_package at line 89, avg 2µs/call # 9 times (36µs+1.07ms) by Role::Tiny::apply_roles_to_package at line 238, avg 123µs/call
sub _install_modifiers {
360198µs my ($me, $to, $name) = @_;
3611947µs return unless my $modifiers = $INFO{$name}{modifiers};
36239µs if (my $info = $INFO{$to}) {
363 push @{$info->{modifiers}}, @{$modifiers||[]};
364 } else {
36521µs foreach my $modifier (@{$modifiers||[]}) {
366411µs41.07ms $me->_install_single_modifier($to, @$modifier);
# spent 1.07ms making 4 calls to Moo::Role::_install_single_modifier, avg 269µs/call
367 }
368 }
369}
370
3711100nsmy $vcheck_error;
372
373sub _install_single_modifier {
374 my ($me, @args) = @_;
375 defined($vcheck_error) or $vcheck_error = do {
376 local $@;
377 eval { Class::Method::Modifiers->VERSION(1.05); 1 }
378 ? 0
379 : $@
380 };
381 $vcheck_error and die $vcheck_error;
382 Class::Method::Modifiers::install_modifier(@args);
383}
384
38512µsmy $FALLBACK = sub { 0 };
386
# spent 362µs (235+127) within Role::Tiny::_install_does which was called 19 times, avg 19µs/call: # 19 times (235µs+127µs) by Role::Tiny::_install_methods at line 356, avg 19µs/call
sub _install_does {
387197µs my ($me, $to) = @_;
388
389 # only add does() method to classes
3901913µs return if $INFO{$to};
391
392 # add does() only if they don't have one
3931683µs1642µs *{_getglob "${to}::does"} = \&does_role unless $to->can('does');
# spent 42µs making 16 calls to UNIVERSAL::can, avg 3µs/call
394
39516170µs4862µs return if ($to->can('DOES') and $to->can('DOES') != (UNIVERSAL->can('DOES') || 0));
# spent 62µs making 48 calls to UNIVERSAL::can, avg 1µs/call
396
397826µs89µs my $existing = $to->can('DOES') || $to->can('isa') || $FALLBACK;
# spent 9µs making 8 calls to UNIVERSAL::can, avg 1µs/call
398 my $new_sub = sub {
399 my ($proto, $role) = @_;
400 Role::Tiny::does_role($proto, $role) or $proto->$existing($role);
401822µs };
4022311µs231µs
# spent 21µs (10+10) within Role::Tiny::BEGIN@402 which was called: # once (10µs+10µs) by Moo::Role::BEGIN@5 at line 402
no warnings 'redefine';
# spent 21µs making 1 call to Role::Tiny::BEGIN@402 # spent 10µs making 1 call to warnings::unimport
403830µs814µs *{_getglob "${to}::DOES"} = $new_sub;
# spent 14µs making 8 calls to Role::Tiny::_getglob, avg 2µs/call
404}
405
406
# spent 44µs (35+9) within Role::Tiny::does_role which was called 6 times, avg 7µs/call: # 3 times (13µs+3µs) by Search::Elasticsearch::Util::is_compat at line 101 of /opt/flows/lib/lib/perl5/Search/Elasticsearch/Util.pm, avg 6µs/call # 2 times (12µs+4µs) by Search::Elasticsearch::Util::is_compat at line 96 of /opt/flows/lib/lib/perl5/Search/Elasticsearch/Util.pm, avg 8µs/call # once (10µs+2µs) by Search::Elasticsearch::Util::is_compat at line 69 of Moo/Object.pm
sub does_role {
40763µs my ($proto, $role) = @_;
40864µs if ($] >= 5.010) {
409 require mro;
410 } else {
411 require MRO::Compat;
412 }
413626µs69µs foreach my $class (@{mro::get_linear_isa(ref($proto)||$proto)}) {
# spent 9µs making 6 calls to mro::get_linear_isa, avg 1µs/call
414620µs return 1 if exists $APPLIED_TO{$class}{$role};
415 }
416 return 0;
417}
418
419sub is_role {
420 my ($me, $role) = @_;
421 return !!$INFO{$role};
422}
423
42414µs1;
425
426=encoding utf-8
427
428=head1 NAME
429
430Role::Tiny - Roles. Like a nouvelle cuisine portion size slice of Moose.
431
432=head1 SYNOPSIS
433
434 package Some::Role;
435
436 use Role::Tiny;
437
438 sub foo { ... }
439
440 sub bar { ... }
441
442 around baz => sub { ... }
443
444 1;
445
446else where
447
448 package Some::Class;
449
450 use Role::Tiny::With;
451
452 # bar gets imported, but not foo
453 with 'Some::Role';
454
455 sub foo { ... }
456
457 # baz is wrapped in the around modifier by Class::Method::Modifiers
458 sub baz { ... }
459
460 1;
461
462If you wanted attributes as well, look at L<Moo::Role>.
463
464=head1 DESCRIPTION
465
466C<Role::Tiny> is a minimalist role composition tool.
467
468=head1 ROLE COMPOSITION
469
470Role composition can be thought of as much more clever and meaningful multiple
471inheritance. The basics of this implementation of roles is:
472
473=over 2
474
475=item *
476
477If a method is already defined on a class, that method will not be composed in
478from the role.
479
480=item *
481
482If a method that the role L</requires> to be implemented is not implemented,
483role application will fail loudly.
484
485=back
486
487Unlike L<Class::C3>, where the B<last> class inherited from "wins," role
488composition is the other way around, where the class wins. If multiple roles
489are applied in a single call (single with statement), then if any of their
490provided methods clash, an exception is raised unless the class provides
491a method since this conflict indicates a potential problem.
492
493=head1 IMPORTED SUBROUTINES
494
495=head2 requires
496
497 requires qw(foo bar);
498
499Declares a list of methods that must be defined to compose role.
500
501=head2 with
502
503 with 'Some::Role1';
504
505 with 'Some::Role1', 'Some::Role2';
506
507Composes another role into the current role (or class via L<Role::Tiny::With>).
508
509If you have conflicts and want to resolve them in favour of Some::Role1 you
510can instead write:
511
512 with 'Some::Role1';
513 with 'Some::Role2';
514
515If you have conflicts and want to resolve different conflicts in favour of
516different roles, please refactor your codebase.
517
518=head2 before
519
520 before foo => sub { ... };
521
522See L<< Class::Method::Modifiers/before method(s) => sub { ... } >> for full
523documentation.
524
525Note that since you are not required to use method modifiers,
526L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
527a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
528both L<Class::Method::Modifiers> and L<Role::Tiny>.
529
530=head2 around
531
532 around foo => sub { ... };
533
534See L<< Class::Method::Modifiers/around method(s) => sub { ... } >> for full
535documentation.
536
537Note that since you are not required to use method modifiers,
538L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
539a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
540both L<Class::Method::Modifiers> and L<Role::Tiny>.
541
542=head2 after
543
544 after foo => sub { ... };
545
546See L<< Class::Method::Modifiers/after method(s) => sub { ... } >> for full
547documentation.
548
549Note that since you are not required to use method modifiers,
550L<Class::Method::Modifiers> is lazily loaded and we do not declare it as
551a dependency. If your L<Role::Tiny> role uses modifiers you must depend on
552both L<Class::Method::Modifiers> and L<Role::Tiny>.
553
554=head1 SUBROUTINES
555
556=head2 does_role
557
558 if (Role::Tiny::does_role($foo, 'Some::Role')) {
559 ...
560 }
561
562Returns true if class has been composed with role.
563
564This subroutine is also installed as ->does on any class a Role::Tiny is
565composed into unless that class already has an ->does method, so
566
567 if ($foo->does('Some::Role')) {
568 ...
569 }
570
571will work for classes but to test a role, one must use ::does_role directly.
572
573Additionally, Role::Tiny will override the standard Perl C<DOES> method
574for your class. However, if C<any> class in your class' inheritance
575hierarchy provides C<DOES>, then Role::Tiny will not override it.
576
577=head1 METHODS
578
579=head2 apply_roles_to_package
580
581 Role::Tiny->apply_roles_to_package(
582 'Some::Package', 'Some::Role', 'Some::Other::Role'
583 );
584
585Composes role with package. See also L<Role::Tiny::With>.
586
587=head2 apply_roles_to_object
588
589 Role::Tiny->apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));
590
591Composes roles in order into object directly. Object is reblessed into the
592resulting class.
593
594=head2 create_class_with_roles
595
596 Role::Tiny->create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));
597
598Creates a new class based on base, with the roles composed into it in order.
599New class is returned.
600
601=head2 is_role
602
603 Role::Tiny->is_role('Some::Role1')
604
605Returns true if the given package is a role.
606
607=head1 SEE ALSO
608
609L<Role::Tiny> is the attribute-less subset of L<Moo::Role>; L<Moo::Role> is
610a meta-protocol-less subset of the king of role systems, L<Moose::Role>.
611
612If you don't want method modifiers and do want to be forcibly restricted
613to a single role application per class, Ovid's L<Role::Basic> exists. But
614Stevan Little (the L<Moose> author) and I don't find the additional
615restrictions to be amazingly helpful in most cases; L<Role::Basic>'s choices
616are more a guide to what you should prefer doing, to our mind, rather than
617something that needs to be enforced.
618
619=head1 AUTHOR
620
621mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
622
623=head1 CONTRIBUTORS
624
625dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
626
627frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <frioux@gmail.com>
628
629hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
630
631jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
632
633ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
634
635chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
636
637ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
638
639doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
640
641perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
642
643Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
644
645ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
646
647tobyink - Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>
648
649=head1 COPYRIGHT
650
651Copyright (c) 2010-2012 the Role::Tiny L</AUTHOR> and L</CONTRIBUTORS>
652as listed above.
653
654=head1 LICENSE
655
656This library is free software and may be distributed under the same terms
657as perl itself.
658
659=cut
 
# spent 6µs within Role::Tiny::CORE:sort which was called 4 times, avg 2µs/call: # 4 times (6µs+0s) by Role::Tiny::_composite_info_for at line 247, avg 2µs/call
sub Role::Tiny::CORE:sort; # opcode
# spent 46µs within Role::Tiny::CORE:subst which was called 19 times, avg 2µs/call: # 19 times (46µs+0s) by Role::Tiny::_load_module at line 28, avg 2µs/call
sub Role::Tiny::CORE:subst; # opcode
Report produced by the NYTProf 5.06 Perl profiler, developed by Tim Bunce and Adam Kaplan.