← 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:06 2010

File /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Object.pm
Statements Executed 37
Statement Execution Time 960µs
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
111198µs230µsMoose::Object::::BEGIN@12Moose::Object::BEGIN@12
11151µs52µsMoose::Object::::BEGIN@106Moose::Object::BEGIN@106
11117µs20µsMoose::Object::::BEGIN@4Moose::Object::BEGIN@4
11114µs1.12msMoose::Object::::BEGIN@13Moose::Object::BEGIN@13
11111µs28µsMoose::Object::::BEGIN@98Moose::Object::BEGIN@98
1119µs28µsMoose::Object::::BEGIN@80Moose::Object::BEGIN@80
1117µs17µsMoose::Object::::BEGIN@5Moose::Object::BEGIN@5
1114µs4µsMoose::Object::::BEGIN@7Moose::Object::BEGIN@7
1113µs3µsMoose::Object::::BEGIN@10Moose::Object::BEGIN@10
1113µs3µsMoose::Object::::BEGIN@8Moose::Object::BEGIN@8
1112µs2µsMoose::Object::::BEGIN@9Moose::Object::BEGIN@9
0000s0sMoose::Object::::BUILDALLMoose::Object::BUILDALL
0000s0sMoose::Object::::BUILDARGSMoose::Object::BUILDARGS
0000s0sMoose::Object::::DEMOLISHALLMoose::Object::DEMOLISHALL
0000s0sMoose::Object::::DESTROYMoose::Object::DESTROY
0000s0sMoose::Object::::__ANON__[:100]Moose::Object::__ANON__[:100]
0000s0sMoose::Object::::__ANON__[:94]Moose::Object::__ANON__[:94]
0000s0sMoose::Object::::doesMoose::Object::does
0000s0sMoose::Object::::dumpMoose::Object::dump
0000s0sMoose::Object::::newMoose::Object::new
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1
2package Moose::Object;
3
4322µs223µs
# spent 20µs (17+3) within Moose::Object::BEGIN@4 which was called # once (17µs+3µs) by Moose::BEGIN@24 at line 4
use strict;
# spent 20µs making 1 call to Moose::Object::BEGIN@4 # spent 3µs making 1 call to strict::import
5325µs226µs
# spent 17µs (7+9) within Moose::Object::BEGIN@5 which was called # once (7µs+9µs) by Moose::BEGIN@24 at line 5
use warnings;
# spent 17µs making 1 call to Moose::Object::BEGIN@5 # spent 9µs making 1 call to warnings::import
6
7317µs14µs
# spent 4µs within Moose::Object::BEGIN@7 which was called # once (4µs+0s) by Moose::BEGIN@24 at line 7
use Devel::GlobalDestruction ();
# spent 4µs making 1 call to Moose::Object::BEGIN@7
8315µs13µs
# spent 3µs within Moose::Object::BEGIN@8 which was called # once (3µs+0s) by Moose::BEGIN@24 at line 8
use MRO::Compat ();
# spent 3µs making 1 call to Moose::Object::BEGIN@8
9314µs12µs
# spent 2µs within Moose::Object::BEGIN@9 which was called # once (2µs+0s) by Moose::BEGIN@24 at line 9
use Scalar::Util ();
# spent 2µs making 1 call to Moose::Object::BEGIN@9
10325µs13µs
# spent 3µs within Moose::Object::BEGIN@10 which was called # once (3µs+0s) by Moose::BEGIN@24 at line 10
use Try::Tiny ();
# spent 3µs making 1 call to Moose::Object::BEGIN@10
11
123216µs2234µs
# spent 230µs (198+32) within Moose::Object::BEGIN@12 which was called # once (198µs+32µs) by Moose::BEGIN@24 at line 12
use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
# spent 230µs making 1 call to Moose::Object::BEGIN@12 # spent 4µs making 1 call to if::import
133263µs21.13ms
# spent 1.12ms (14µs+1.11) within Moose::Object::BEGIN@13 which was called # once (14µs+1.11ms) by Moose::BEGIN@24 at line 13
use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
# spent 1.12ms making 1 call to Moose::Object::BEGIN@13 # spent 3µs making 1 call to if::import
14
151700nsour $VERSION = '0.98';
16119µs$VERSION = eval $VERSION;
171300nsour $AUTHORITY = 'cpan:STEVAN';
18
19sub new {
20 my $class = shift;
21
22 my $params = $class->BUILDARGS(@_);
23
24 my $real_class = Scalar::Util::blessed($class) || $class;
25 my $self = Class::MOP::Class->initialize($real_class)->new_object($params);
26
27 $self->BUILDALL($params);
28
29 return $self;
30}
31
32sub BUILDARGS {
33 my $class = shift;
34 if ( scalar @_ == 1 ) {
35 unless ( defined $_[0] && ref $_[0] eq 'HASH' ) {
36 Class::MOP::class_of($class)->throw_error(
37 "Single parameters to new() must be a HASH ref",
38 data => $_[0] );
39 }
40 return { %{ $_[0] } };
41 }
42 else {
43 return {@_};
44 }
45}
46
47sub BUILDALL {
48 # NOTE: we ask Perl if we even
49 # need to do this first, to avoid
50 # extra meta level calls
51 return unless $_[0]->can('BUILD');
52 my ($self, $params) = @_;
53 foreach my $method (reverse Class::MOP::class_of($self)->find_all_methods_by_name('BUILD')) {
54 $method->{code}->execute($self, $params);
55 }
56}
57
58sub DEMOLISHALL {
59 my $self = shift;
60 my ($in_global_destruction) = @_;
61
62 # NOTE: we ask Perl if we even
63 # need to do this first, to avoid
64 # extra meta level calls
65 return unless $self->can('DEMOLISH');
66
67 my @isa;
68 if ( my $meta = Class::MOP::class_of($self ) ) {
69 @isa = $meta->linearized_isa;
70 } else {
71 # We cannot count on being able to retrieve a previously made
72 # metaclass, _or_ being able to make a new one during global
73 # destruction. However, we should still be able to use mro at
74 # that time (at least tests suggest so ;)
75 my $class_name = ref $self;
76 @isa = @{ mro::get_linear_isa($class_name) }
77 }
78
79 foreach my $class (@isa) {
80399µs247µs
# spent 28µs (9+19) within Moose::Object::BEGIN@80 which was called # once (9µs+19µs) by Moose::BEGIN@24 at line 80
no strict 'refs';
# spent 28µs making 1 call to Moose::Object::BEGIN@80 # spent 19µs making 1 call to strict::unimport
81 my $demolish = *{"${class}::DEMOLISH"}{CODE};
82 $self->$demolish($in_global_destruction)
83 if defined $demolish;
84 }
85}
86
87sub DESTROY {
88 my $self = shift;
89
90 local $?;
91
92 Try::Tiny::try {
93 $self->DEMOLISHALL(Devel::GlobalDestruction::in_global_destruction);
94 }
95 Try::Tiny::catch {
96 # Without this, Perl will warn "\t(in cleanup)$@" because of some
97 # bizarre fucked-up logic deep in the internals.
98387µs245µs
# spent 28µs (11+17) within Moose::Object::BEGIN@98 which was called # once (11µs+17µs) by Moose::BEGIN@24 at line 98
no warnings 'misc';
# spent 28µs making 1 call to Moose::Object::BEGIN@98 # spent 17µs making 1 call to warnings::unimport
99 die $_;
100 };
101
102 return;
103}
104
105# support for UNIVERSAL::DOES ...
106
# spent 52µs (51+1) within Moose::Object::BEGIN@106 which was called # once (51µs+1µs) by Moose::BEGIN@24 at line 113
BEGIN {
107253µs11µs my $does = UNIVERSAL->can("DOES") ? "SUPER::DOES" : "isa";
# spent 1µs making 1 call to UNIVERSAL::can
108 eval 'sub DOES {
109 my ( $self, $class_or_role_name ) = @_;
110 return $self->'.$does.'($class_or_role_name)
111 || $self->does($class_or_role_name);
112 }';
1131100µs152µs}
# spent 52µs making 1 call to Moose::Object::BEGIN@106
114
115# new does() methods will be created
116# as appropiate see Moose::Meta::Role
117sub does {
118 my ($self, $role_name) = @_;
119 my $meta = Class::MOP::class_of($self);
120 (defined $role_name)
121 || $meta->throw_error("You must supply a role name to does()");
122 return 1 if $meta->can('does_role') && $meta->does_role($role_name);
123 return 0;
124}
125
126sub dump {
127 my $self = shift;
128 require Data::Dumper;
129 local $Data::Dumper::Maxdepth = shift if @_;
130 Data::Dumper::Dumper $self;
131}
132
13315µs1;
134
135__END__
136
137=pod
138
139=head1 NAME
140
141Moose::Object - The base object for Moose
142
143=head1 DESCRIPTION
144
145This class is the default base class for all Moose-using classes. When
146you C<use Moose> in this class, your class will inherit from this
147class.
148
149It provides a default constructor and destructor, which run the
150C<BUILDALL> and C<DEMOLISHALL> methods respectively.
151
152You don't actually I<need> to inherit from this in order to use Moose,
153but it makes it easier to take advantage of all of Moose's features.
154
155=head1 METHODS
156
157=over 4
158
159=item B<< Moose::Object->new(%params) >>
160
161This method calls C<< $class->BUILDARGS(@_) >>, and then creates a new
162instance of the appropriate class. Once the instance is created, it
163calls C<< $instance->BUILDALL($params) >>.
164
165=item B<< Moose::Object->BUILDARGS(%params) >>
166
167The default implementation of this method accepts a hash or hash
168reference of named parameters. If it receives a single argument that
169I<isn't> a hash reference it throws an error.
170
171You can override this method in your class to handle other types of
172options passed to the constructor.
173
174This method should always return a hash reference of named options.
175
176=item B<< $object->BUILDALL($params) >>
177
178This method will call every C<BUILD> method in the inheritance
179hierarchy, starting with the most distant parent class and ending with
180the object's class.
181
182The C<BUILD> method will be passed the hash reference returned by
183C<BUILDARGS>.
184
185=item B<< $object->DEMOLISHALL >>
186
187This will call every C<DEMOLISH> method in the inheritance hierarchy,
188starting with the object's class and ending with the most distant
189parent. C<DEMOLISHALL> and C<DEMOLISH> will receive a boolean
190indicating whether or not we are currently in global destruction.
191
192=item B<< $object->does($role_name) >>
193
194This returns true if the object does the given role.
195
196=item B<DOES ($class_or_role_name)>
197
198This is a a Moose role-aware implementation of L<UNIVERSAL/DOES>.
199
200This is effectively the same as writing:
201
202 $object->does($name) || $object->isa($name)
203
204This method will work with Perl 5.8, which did not implement
205C<UNIVERSAL::DOES>.
206
207=item B<< $object->dump($maxdepth) >>
208
209This is a handy utility for C<Data::Dumper>ing an object. By default,
210the maximum depth is 1, to avoid making a mess.
211
212=back
213
214=head1 BUGS
215
216See L<Moose/BUGS> for details on reporting bugs.
217
218=head1 AUTHOR
219
220Stevan Little E<lt>stevan@iinteractive.comE<gt>
221
222=head1 COPYRIGHT AND LICENSE
223
224Copyright 2006-2010 by Infinity Interactive, Inc.
225
226L<http://www.iinteractive.com>
227
228This library is free software; you can redistribute it and/or modify
229it under the same terms as Perl itself.
230
231=cut