← Index
Performance Profile   « block view • line view • sub view »
For t/test-parsing
  Run on Sun Nov 14 09:49:57 2010
Reported on Sun Nov 14 09:50:10 2010

File /usr/local/lib/perl/5.10.0/Class/MOP.pm
Statements Executed 3200
Total Time 0.0143105 seconds
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1591746.61ms6.61msClass::MOP::::get_metaclass_by_nameClass::MOP::get_metaclass_by_name
574332.35ms2.35msClass::MOP::::get_code_infoClass::MOP::get_code_info(xsub)
4111.96ms25.4msClass::MOP::::__ANON__[:117]Class::MOP::__ANON__[:117]
71111.30ms29.4msClass::MOP::::load_first_existing_classClass::MOP::load_first_existing_class
7322987µs987µsClass::MOP::::_is_valid_class_nameClass::MOP::_is_valid_class_name
13023924µs924µsClass::MOP::::is_class_loadedClass::MOP::is_class_loaded(xsub)
7154550µs29.9msClass::MOP::::load_classClass::MOP::load_class
7322450µs450µsClass::MOP::::store_metaclass_by_nameClass::MOP::store_metaclass_by_name
3744289µs386µsClass::MOP::::class_ofClass::MOP::class_of
81160µs60µsClass::MOP::::__ANON__[:233]Class::MOP::__ANON__[:233]
81158µs58µsClass::MOP::::__ANON__[:320]Class::MOP::__ANON__[:320]
92253µs53µsClass::MOP::::__ANON__[:509]Class::MOP::__ANON__[:509]
81153µs53µsClass::MOP::::__ANON__[:301]Class::MOP::__ANON__[:301]
41151µs51µsClass::MOP::::_class_to_pmfileClass::MOP::_class_to_pmfile
81145µs45µsClass::MOP::::__ANON__[:191]Class::MOP::__ANON__[:191]
81143µs43µsClass::MOP::::__ANON__[:336]Class::MOP::__ANON__[:336]
81141µs41µsClass::MOP::::__ANON__[:275]Class::MOP::__ANON__[:275]
0000s0sClass::MOP::::BEGINClass::MOP::BEGIN
0000s0sClass::MOP::::__ANON__[:124]Class::MOP::__ANON__[:124]
0000s0sClass::MOP::::__ANON__[:516]Class::MOP::__ANON__[:516]
0000s0sClass::MOP::::__ANON__[:614]Class::MOP::__ANON__[:614]
0000s0sClass::MOP::::does_metaclass_existClass::MOP::does_metaclass_exist
0000s0sClass::MOP::::get_all_metaclass_instancesClass::MOP::get_all_metaclass_instances
0000s0sClass::MOP::::get_all_metaclass_namesClass::MOP::get_all_metaclass_names
0000s0sClass::MOP::::get_all_metaclassesClass::MOP::get_all_metaclasses
0000s0sClass::MOP::::remove_metaclass_by_nameClass::MOP::remove_metaclass_by_name
0000s0sClass::MOP::::weaken_metaclassClass::MOP::weaken_metaclass
LineStmts.Exclusive
Time
Avg.Code
1
2package Class::MOP;
3
4336µs12µsuse strict;
# spent 7µs making 1 call to strict::import
5329µs10µsuse warnings;
# spent 23µs making 1 call to warnings::import
6
7341µs14µsuse 5.008;
8
93111µs37µsuse MRO::Compat;
# spent 4µs making 1 call to import
10
11337µs12µsuse Carp 'confess';
# spent 63µs making 1 call to Exporter::import
123151µs50µsuse Scalar::Util 'weaken', 'reftype', 'blessed';
# spent 78µs making 1 call to Exporter::import
133117µs39µsuse Data::OptList;
143127µs42µsuse Try::Tiny;
# spent 58µs making 1 call to Exporter::import
15
163115µs38µsuse Class::MOP::Mixin::AttributeCore;
# spent 8µs making 1 call to import
173114µs38µsuse Class::MOP::Mixin::HasAttributes;
# spent 4µs making 1 call to import
183117µs39µsuse Class::MOP::Mixin::HasMethods;
# spent 6µs making 1 call to import
193123µs41µsuse Class::MOP::Class;
# spent 6µs making 1 call to import
203132µs44µsuse Class::MOP::Attribute;
# spent 7µs making 1 call to import
21380µs27µsuse Class::MOP::Method;
# spent 3µs making 1 call to import
22
23BEGIN {
24 *IS_RUNNING_ON_5_10 = ($] < 5.009_005)
25 ? sub () { 0 }
2626µs3µs : sub () { 1 };
27
28 # this is either part of core or set up appropriately by MRO::Compat
29 *check_package_cache_flag = \&mro::get_pkg_gen;
3012.86ms2.86ms}
31
3211µs1µsour $VERSION = '1.09';
331600ns600nsour $XS_VERSION = $VERSION;
34129µs29µs$VERSION = eval $VERSION;
351500ns500nsour $AUTHORITY = 'cpan:STEVAN';
36
371800ns800nsrequire XSLoader;
381349µs349µsXSLoader::load( __PACKAGE__, $XS_VERSION );
# spent 347µs making 1 call to XSLoader::load
39
40{
41 # Metaclasses are singletons, so we cache them here.
42 # there is no need to worry about destruction though
43 # because they should die only when the program dies.
44 # After all, do package definitions even get reaped?
45 # Anonymous classes manage their own destruction.
4622µs750ns my %METAS;
47
48 sub get_all_metaclasses { %METAS }
49 sub get_all_metaclass_instances { values %METAS }
50 sub get_all_metaclass_names { keys %METAS }
5115913.37ms2µs
# spent 6.61ms within Class::MOP::get_metaclass_by_name which was called 1591 times, avg 4µs/call: # 1415 times (5.99ms+0s) by Class::MOP::Class::initialize at line 45 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 4µs/call # 77 times (268µs+0s) by Class::MOP::Class::_single_metaclass_is_compatible at line 288 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 3µs/call # 71 times (240µs+0s) by Class::MOP::Class::_construct_class_instance at line 82 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 3µs/call # 11 times (44µs+0s) by Class::MOP::Class::_class_metaclass_is_compatible at line 258 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 4µs/call # 8 times (28µs+0s) by Moose::Meta::Class::initialize at line 68 of /usr/local/lib/perl/5.10.0/Moose/Meta/Class.pm, avg 3µs/call # 7 times (33µs+0s) by Moose::init_meta at line 167 of /usr/local/lib/perl/5.10.0/Moose.pm, avg 5µs/call # 2 times (12µs+0s) by Class::MOP::Package::initialize at line 30 of /usr/local/lib/perl/5.10.0/Class/MOP/Package.pm, avg 6µs/call
sub get_metaclass_by_name { $METAS{$_[0]} }
5273231µs3µs
# spent 450µs within Class::MOP::store_metaclass_by_name which was called 73 times, avg 6µs/call: # 71 times (438µs+0s) by Class::MOP::Class::_construct_class_instance at line 107 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 6µs/call # 2 times (11µs+0s) by Class::MOP::Package::initialize at line 37 of /usr/local/lib/perl/5.10.0/Class/MOP/Package.pm, avg 6µs/call
sub store_metaclass_by_name { $METAS{$_[0]} = $_[1] }
53 sub weaken_metaclass { weaken($METAS{$_[0]}) }
54 sub does_metaclass_exist { exists $METAS{$_[0]} && defined $METAS{$_[0]} }
55 sub remove_metaclass_by_name { delete $METAS{$_[0]}; return }
56
57 # This handles instances as well as class names
58
# spent 386µs (289+97) within Class::MOP::class_of which was called 37 times, avg 10µs/call: # 16 times (117µs+46µs) by Moose::Exporter::_make_wrapped_sub_with_meta or Moose::Exporter::__ANON__[/usr/local/lib/perl/5.10.0/Moose/Exporter.pm:292] or Moose::Exporter::__ANON__[/usr/local/lib/perl/5.10.0/Moose/Exporter.pm:284] at line 284 of /usr/local/lib/perl/5.10.0/Moose/Exporter.pm, avg 10µs/call # 11 times (85µs+28µs) by Moose::Meta::Class::superclasses at line 283 of /usr/local/lib/perl/5.10.0/Moose/Meta/Class.pm, avg 10µs/call # 9 times (78µs+16µs) at line 693 of /usr/local/lib/perl/5.10.0/Moose/Util/TypeConstraints.pm, avg 11µs/call # once (9µs+7µs) by Class::MOP::Object::_new at line 22 of /usr/local/lib/perl/5.10.0/Class/MOP/Object.pm
sub class_of {
59111284µs3µs return unless defined $_[0];
60 my $class = blessed($_[0]) || $_[0];
# spent 97µs making 37 calls to Scalar::Util::blessed, avg 3µs/call
61 return $METAS{$class};
62 }
63
64 # NOTE:
65 # We only cache metaclasses, meaning instances of
66 # Class::MOP::Class. We do not cache instance of
67 # Class::MOP::Package or Class::MOP::Module. Mostly
68 # because I don't yet see a good reason to do so.
69}
70
71
# spent 51µs within Class::MOP::_class_to_pmfile which was called 4 times, avg 13µs/call: # 4 times (51µs+0s) by Class::MOP::load_first_existing_class at line 110, avg 13µs/call
sub _class_to_pmfile {
721639µs2µs my $class = shift;
73
74 my $file = $class . '.pm';
75 $file =~ s{::}{/}g;
76
77 return $file;
78}
79
80
# spent 29.4ms (1.30+28.1) within Class::MOP::load_first_existing_class which was called 71 times, avg 414µs/call: # 71 times (1.30ms+28.1ms) by Class::MOP::load_class at line 136, avg 414µs/call
sub load_first_existing_class {
81355622µs2µs my $classes = Data::OptList::mkopt(\@_)
# spent 1.46ms making 71 calls to Data::OptList::mkopt, avg 21µs/call
82 or return;
83
84 foreach my $class (@{ $classes }) {
85142465µs3µs my $name = $class->[0];
86 unless ( _is_valid_class_name($name) ) {
# spent 953µs making 71 calls to Class::MOP::_is_valid_class_name, avg 13µs/call
87 my $display = defined($name) ? $name : 'undef';
88 confess "Invalid class name ($display)";
89 }
90 }
91
92 my $found;
93 my %exceptions;
94
95 for my $class (@{ $classes }) {
96150285µs2µs my ($name, $options) = @{ $class };
97
9871802µs11µs if ($options) {
99 return $name if is_class_loaded($name, $options);
100 if (is_class_loaded($name)) {
101 # we already know it's loaded and too old, but we call
102 # ->VERSION anyway to generate the exception for us
103 $name->VERSION($options->{-version});
104 }
105 }
106 else {
107 return $name if is_class_loaded($name);
# spent 517µs making 71 calls to Class::MOP::is_class_loaded, avg 7µs/call
108 }
109
110 my $file = _class_to_pmfile($name);
# spent 51µs making 4 calls to Class::MOP::_class_to_pmfile, avg 13µs/call
111
# spent 25.4ms (1.96+23.4) within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:117] which was called 4 times, avg 6.34ms/call: # 4 times (1.96ms+23.4ms) by Try::Tiny::try at line 71 of /usr/local/share/perl/5.10.0/Try/Tiny.pm, avg 6.34ms/call
return $name if try {
11216439µs27µs local $SIG{__DIE__};
113 require $file;
114 $name->VERSION($options->{-version})
115 if defined $options->{-version};
116 return 1;
117 }
118 catch {
119 unless (/^Can't locate \Q$file\E in \@INC/) {
120 confess "Couldn't load class ($name) because: $_";
121 }
122
123 return;
124 };
# spent 25.5ms making 4 calls to Try::Tiny::try, avg 6.36ms/call # spent 40µs making 4 calls to Try::Tiny::catch, avg 10µs/call
125 }
126
127 if ( @{ $classes } > 1 ) {
128 my @list = map { $_->[0] } @{ $classes };
129 confess "Can't locate any of @list in \@INC (\@INC contains: @INC).";
130 } else {
131 confess "Can't locate " . _class_to_pmfile($classes->[0]->[0]) . " in \@INC (\@INC contains: @INC).";
132 }
133}
134
135
# spent 29.9ms (550µs+29.4) within Class::MOP::load_class which was called 71 times, avg 422µs/call: # 38 times (263µs+2.12ms) by Class::MOP::Class::_inline_constructor at line 1296 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 63µs/call # 14 times (112µs+2.56ms) by Class::MOP::MiniTrait::apply at line 14 of /usr/local/lib/perl/5.10.0/Class/MOP/MiniTrait.pm, avg 191µs/call # 11 times (102µs+24.4ms) by Moose::Meta::Class::superclasses at line 282 of /usr/local/lib/perl/5.10.0/Moose/Meta/Class.pm, avg 2.22ms/call # 7 times (66µs+269µs) by Class::MOP::Class::_inline_destructor at line 1328 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 48µs/call # once (8µs+64µs) by metaclass::import at line 29 of /usr/local/lib/perl/5.10.0/metaclass.pm
sub load_class {
136142437µs3µs load_first_existing_class($_[0], ref $_[1] ? $_[1] : ());
# spent 29.8ms making 71 calls to Class::MOP::load_first_existing_class, avg 414µs/call, max recursion depth 1
137
138 # This is done to avoid breaking code which checked the return value. Said
139 # code is dumb. The return value was _always_ true, since it dies on
140 # failure!
141 return 1;
142}
143
144
# spent 987µs within Class::MOP::_is_valid_class_name which was called 73 times, avg 14µs/call: # 71 times (953µs+0s) by Class::MOP::load_first_existing_class at line 86, avg 13µs/call # 2 times (34µs+0s) by Class::MOP::Module::_instantiate_module at line 61 of /usr/local/lib/perl/5.10.0/Class/MOP/Module.pm, avg 17µs/call
sub _is_valid_class_name {
145365729µs2µs my $class = shift;
146
147 return 0 if ref($class);
148 return 0 unless defined($class);
149 return 0 unless length($class);
150
151 return 1 if $class =~ /^\w+(?:::\w+)*$/;
152
153 return 0;
154}
155
156## ----------------------------------------------------------------------------
157## Setting up our environment ...
158## ----------------------------------------------------------------------------
159## Class::MOP needs to have a few things in the global perl environment so
160## that it can operate effectively. Those things are done here.
161## ----------------------------------------------------------------------------
162
163# ... nothing yet actually ;)
164
165## ----------------------------------------------------------------------------
166## Bootstrapping
167## ----------------------------------------------------------------------------
168## The code below here is to bootstrap our MOP with itself. This is also
169## sometimes called "tying the knot". By doing this, we make it much easier
170## to extend the MOP through subclassing and such since now you can use the
171## MOP itself to extend itself.
172##
173## Yes, I know, thats weird and insane, but it's a good thing, trust me :)
174## ----------------------------------------------------------------------------
175
176# We need to add in the meta-attributes here so that
177# any subclass of Class::MOP::* will be able to
178# inherit them using _construct_instance
179
180## --------------------------------------------------------
181## Class::MOP::Mixin::HasMethods
182
183Class::MOP::Mixin::HasMethods->meta->add_attribute(
184 Class::MOP::Attribute->new('_methods' => (
185 reader => {
186 # NOTE:
187 # we just alias the original method
188 # rather than re-produce it here
189 '_full_method_map' => \&Class::MOP::Mixin::HasMethods::_full_method_map
190 },
191812µs1µs
# spent 45µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:191] which was called 8 times, avg 6µs/call: # 8 times (45µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 6µs/call
default => sub { {} }
192138µs38µs ))
# spent 1.04ms making 1 call to Class::MOP::Mixin::meta # spent 832µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 74µs making 1 call to Class::MOP::Attribute::new
193);
194
195121µs21µsClass::MOP::Mixin::HasMethods->meta->add_attribute(
# spent 410µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 42µs making 1 call to Class::MOP::Attribute::new # spent 24µs making 1 call to Class::MOP::Mixin::meta
196 Class::MOP::Attribute->new('method_metaclass' => (
197 reader => {
198 # NOTE:
199 # we just alias the original method
200 # rather than re-produce it here
201 'method_metaclass' => \&Class::MOP::Mixin::HasMethods::method_metaclass
202 },
203 default => 'Class::MOP::Method',
204 ))
205);
206
207117µs17µsClass::MOP::Mixin::HasMethods->meta->add_attribute(
# spent 368µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 35µs making 1 call to Class::MOP::Attribute::new # spent 23µs making 1 call to Class::MOP::Mixin::meta
208 Class::MOP::Attribute->new('wrapped_method_metaclass' => (
209 reader => {
210 # NOTE:
211 # we just alias the original method
212 # rather than re-produce it here
213 'wrapped_method_metaclass' => \&Class::MOP::Mixin::HasMethods::wrapped_method_metaclass
214 },
215 default => 'Class::MOP::Method::Wrapped',
216 ))
217);
218
219## --------------------------------------------------------
220## Class::MOP::Mixin::HasMethods
221
222Class::MOP::Mixin::HasAttributes->meta->add_attribute(
223 Class::MOP::Attribute->new('attributes' => (
224 reader => {
225 # NOTE: we need to do this in order
226 # for the instance meta-object to
227 # not fall into meta-circular death
228 #
229 # we just alias the original method
230 # rather than re-produce it here
231 '_attribute_map' => \&Class::MOP::Mixin::HasAttributes::_attribute_map
232 },
233811µs1µs
# spent 60µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:233] which was called 8 times, avg 8µs/call: # 8 times (60µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 8µs/call
default => sub { {} }
234124µs24µs ))
# spent 509µs making 1 call to Class::MOP::Mixin::meta # spent 354µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 45µs making 1 call to Class::MOP::Attribute::new
235);
236
237121µs21µsClass::MOP::Mixin::HasAttributes->meta->add_attribute(
# spent 335µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 41µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Mixin::meta
238 Class::MOP::Attribute->new('attribute_metaclass' => (
239 reader => {
240 # NOTE:
241 # we just alias the original method
242 # rather than re-produce it here
243 'attribute_metaclass' => \&Class::MOP::Mixin::HasAttributes::attribute_metaclass
244 },
245 default => 'Class::MOP::Attribute',
246 ))
247);
248
249## --------------------------------------------------------
250## Class::MOP::Package
251
252126µs26µsClass::MOP::Package->meta->add_attribute(
# spent 650µs making 1 call to Class::MOP::Object::meta # spent 358µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 35µs making 1 call to Class::MOP::Attribute::new
253 Class::MOP::Attribute->new('package' => (
254 reader => {
255 # NOTE: we need to do this in order
256 # for the instance meta-object to
257 # not fall into meta-circular death
258 #
259 # we just alias the original method
260 # rather than re-produce it here
261 'name' => \&Class::MOP::Package::name
262 },
263 ))
264);
265
266Class::MOP::Package->meta->add_attribute(
267 Class::MOP::Attribute->new('namespace' => (
268 reader => {
269 # NOTE:
270 # we just alias the original method
271 # rather than re-produce it here
272 'namespace' => \&Class::MOP::Package::namespace
273 },
274 init_arg => undef,
27589µs1µs
# spent 41µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:275] which was called 8 times, avg 5µs/call: # 8 times (41µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 5µs/call
default => sub { \undef }
276122µs22µs ))
# spent 381µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 43µs making 1 call to Class::MOP::Attribute::new # spent 21µs making 1 call to Class::MOP::Object::meta
277);
278
279## --------------------------------------------------------
280## Class::MOP::Module
281
282# NOTE:
283# yeah this is kind of stretching things a bit,
284# but truthfully the version should be an attribute
285# of the Module, the weirdness comes from having to
286# stick to Perl 5 convention and store it in the
287# $VERSION package variable. Basically if you just
288# squint at it, it will look how you want it to look.
289# Either as a package variable, or as a attribute of
290# the metaclass, isn't abstraction great :)
291
292Class::MOP::Module->meta->add_attribute(
293 Class::MOP::Attribute->new('version' => (
294 reader => {
295 # NOTE:
296 # we just alias the original method
297 # rather than re-produce it here
298 'version' => \&Class::MOP::Module::version
299 },
300 init_arg => undef,
30189µs1µs
# spent 53µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:301] which was called 8 times, avg 7µs/call: # 8 times (53µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 7µs/call
default => sub { \undef }
302132µs32µs ))
# spent 527µs making 1 call to Class::MOP::Object::meta # spent 369µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 49µs making 1 call to Class::MOP::Attribute::new
303);
304
305# NOTE:
306# By following the same conventions as version here,
307# we are opening up the possibility that people can
308# use the $AUTHORITY in non-Class::MOP modules as
309# well.
310
311Class::MOP::Module->meta->add_attribute(
312 Class::MOP::Attribute->new('authority' => (
313 reader => {
314 # NOTE:
315 # we just alias the original method
316 # rather than re-produce it here
317 'authority' => \&Class::MOP::Module::authority
318 },
319 init_arg => undef,
32088µs1µs
# spent 58µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:320] which was called 8 times, avg 7µs/call: # 8 times (58µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 7µs/call
default => sub { \undef }
321124µs24µs ))
# spent 342µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 41µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Object::meta
322);
323
324## --------------------------------------------------------
325## Class::MOP::Class
326
327Class::MOP::Class->meta->add_attribute(
328 Class::MOP::Attribute->new('superclasses' => (
329 accessor => {
330 # NOTE:
331 # we just alias the original method
332 # rather than re-produce it here
333 'superclasses' => \&Class::MOP::Class::superclasses
334 },
335 init_arg => undef,
336812µs1µs
# spent 43µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:336] which was called 8 times, avg 5µs/call: # 8 times (43µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm, avg 5µs/call
default => sub { \undef }
337129µs29µs ))
# spent 970µs making 1 call to Class::MOP::Object::meta # spent 357µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 42µs making 1 call to Class::MOP::Attribute::new
338);
339
340126µs26µsClass::MOP::Class->meta->add_attribute(
# spent 331µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 35µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Object::meta
341 Class::MOP::Attribute->new('instance_metaclass' => (
342 reader => {
343 # NOTE: we need to do this in order
344 # for the instance meta-object to
345 # not fall into meta-circular death
346 #
347 # we just alias the original method
348 # rather than re-produce it here
349 'instance_metaclass' => \&Class::MOP::Class::instance_metaclass
350 },
351 default => 'Class::MOP::Instance',
352 ))
353);
354
355120µs20µsClass::MOP::Class->meta->add_attribute(
# spent 314µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
356 Class::MOP::Attribute->new('immutable_trait' => (
357 reader => {
358 'immutable_trait' => \&Class::MOP::Class::immutable_trait
359 },
360 default => "Class::MOP::Class::Immutable::Trait",
361 ))
362);
363
364128µs28µsClass::MOP::Class->meta->add_attribute(
# spent 349µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 38µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
365 Class::MOP::Attribute->new('constructor_name' => (
366 reader => {
367 'constructor_name' => \&Class::MOP::Class::constructor_name,
368 },
369 default => "new",
370 ))
371);
372
373128µs28µsClass::MOP::Class->meta->add_attribute(
# spent 342µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 37µs making 1 call to Class::MOP::Attribute::new # spent 26µs making 1 call to Class::MOP::Object::meta
374 Class::MOP::Attribute->new('constructor_class' => (
375 reader => {
376 'constructor_class' => \&Class::MOP::Class::constructor_class,
377 },
378 default => "Class::MOP::Method::Constructor",
379 ))
380);
381
382
383126µs26µsClass::MOP::Class->meta->add_attribute(
# spent 314µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 30µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
384 Class::MOP::Attribute->new('destructor_class' => (
385 reader => {
386 'destructor_class' => \&Class::MOP::Class::destructor_class,
387 },
388 ))
389);
390
391# NOTE:
392# we don't actually need to tie the knot with
393# Class::MOP::Class here, it is actually handled
394# within Class::MOP::Class itself in the
395# _construct_class_instance method.
396
397## --------------------------------------------------------
398## Class::MOP::Mixin::AttributeCore
399138µs38µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 485µs making 1 call to Class::MOP::Mixin::meta # spent 353µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new
400 Class::MOP::Attribute->new('name' => (
401 reader => {
402 # NOTE: we need to do this in order
403 # for the instance meta-object to
404 # not fall into meta-circular death
405 #
406 # we just alias the original method
407 # rather than re-produce it here
408 'name' => \&Class::MOP::Mixin::AttributeCore::name
409 }
410 ))
411);
412
413122µs22µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 515µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 34µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Mixin::meta
414 Class::MOP::Attribute->new('accessor' => (
415 reader => { 'accessor' => \&Class::MOP::Mixin::AttributeCore::accessor },
416 predicate => { 'has_accessor' => \&Class::MOP::Mixin::AttributeCore::has_accessor },
417 ))
418);
419
420127µs27µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 493µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 28µs making 1 call to Class::MOP::Attribute::new # spent 23µs making 1 call to Class::MOP::Mixin::meta
421 Class::MOP::Attribute->new('reader' => (
422 reader => { 'reader' => \&Class::MOP::Mixin::AttributeCore::reader },
423 predicate => { 'has_reader' => \&Class::MOP::Mixin::AttributeCore::has_reader },
424 ))
425);
426
427124µs24µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 479µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Mixin::meta
428 Class::MOP::Attribute->new('initializer' => (
429 reader => { 'initializer' => \&Class::MOP::Mixin::AttributeCore::initializer },
430 predicate => { 'has_initializer' => \&Class::MOP::Mixin::AttributeCore::has_initializer },
431 ))
432);
433
434126µs26µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 304µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Mixin::meta
435 Class::MOP::Attribute->new('definition_context' => (
436 reader => { 'definition_context' => \&Class::MOP::Mixin::AttributeCore::definition_context },
437 ))
438);
439
440122µs22µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 520µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 28µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Mixin::meta
441 Class::MOP::Attribute->new('writer' => (
442 reader => { 'writer' => \&Class::MOP::Mixin::AttributeCore::writer },
443 predicate => { 'has_writer' => \&Class::MOP::Mixin::AttributeCore::has_writer },
444 ))
445);
446
447128µs28µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 488µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 37µs making 1 call to Class::MOP::Attribute::new # spent 21µs making 1 call to Class::MOP::Mixin::meta
448 Class::MOP::Attribute->new('predicate' => (
449 reader => { 'predicate' => \&Class::MOP::Mixin::AttributeCore::predicate },
450 predicate => { 'has_predicate' => \&Class::MOP::Mixin::AttributeCore::has_predicate },
451 ))
452);
453
454137µs37µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 502µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 32µs making 1 call to Class::MOP::Attribute::new # spent 23µs making 1 call to Class::MOP::Mixin::meta
455 Class::MOP::Attribute->new('clearer' => (
456 reader => { 'clearer' => \&Class::MOP::Mixin::AttributeCore::clearer },
457 predicate => { 'has_clearer' => \&Class::MOP::Mixin::AttributeCore::has_clearer },
458 ))
459);
460
461128µs28µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 452µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 28µs making 1 call to Class::MOP::Attribute::new # spent 23µs making 1 call to Class::MOP::Mixin::meta
462 Class::MOP::Attribute->new('builder' => (
463 reader => { 'builder' => \&Class::MOP::Mixin::AttributeCore::builder },
464 predicate => { 'has_builder' => \&Class::MOP::Mixin::AttributeCore::has_builder },
465 ))
466);
467
468132µs32µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 468µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Mixin::meta
469 Class::MOP::Attribute->new('init_arg' => (
470 reader => { 'init_arg' => \&Class::MOP::Mixin::AttributeCore::init_arg },
471 predicate => { 'has_init_arg' => \&Class::MOP::Mixin::AttributeCore::has_init_arg },
472 ))
473);
474
475127µs27µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 295µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Mixin::meta
476 Class::MOP::Attribute->new('default' => (
477 # default has a custom 'reader' method ...
478 predicate => { 'has_default' => \&Class::MOP::Mixin::AttributeCore::has_default },
479 ))
480);
481
482124µs24µsClass::MOP::Mixin::AttributeCore->meta->add_attribute(
# spent 649µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 36µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Mixin::meta
483 Class::MOP::Attribute->new('insertion_order' => (
484 reader => { 'insertion_order' => \&Class::MOP::Mixin::AttributeCore::insertion_order },
485 writer => { '_set_insertion_order' => \&Class::MOP::Mixin::AttributeCore::_set_insertion_order },
486 predicate => { 'has_insertion_order' => \&Class::MOP::Mixin::AttributeCore::has_insertion_order },
487 ))
488);
489
490## --------------------------------------------------------
491## Class::MOP::Attribute
492126µs26µsClass::MOP::Attribute->meta->add_attribute(
# spent 735µs making 1 call to Class::MOP::Object::meta # spent 346µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 36µs making 1 call to Class::MOP::Attribute::new
493 Class::MOP::Attribute->new('associated_class' => (
494 reader => {
495 # NOTE: we need to do this in order
496 # for the instance meta-object to
497 # not fall into meta-circular death
498 #
499 # we just alias the original method
500 # rather than re-produce it here
501 'associated_class' => \&Class::MOP::Attribute::associated_class
502 }
503 ))
504);
505
506Class::MOP::Attribute->meta->add_attribute(
507 Class::MOP::Attribute->new('associated_methods' => (
508 reader => { 'associated_methods' => \&Class::MOP::Attribute::associated_methods },
509914µs2µs
# spent 53µs within Class::MOP::__ANON__[/usr/local/lib/perl/5.10.0/Class/MOP.pm:509] which was called 9 times, avg 6µs/call: # 8 times (46µs+0s) by Class::MOP::Method::Generated::__ANON__[(eval 0)[/usr/local/lib/perl/5.10.0/Class/MOP/Method/Generated.pm:53]:95] at line 74 of (eval 0)[/usr/local/lib/perl/5.10.0/Class/MOP/Method/Generated.pm:53] at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Method/Generated.pm, avg 6µs/call # once (8µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/AttributeCore.pm
default => sub { [] }
510125µs25µs ))
# spent 329µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 52µs making 1 call to Class::MOP::Attribute::new # spent 20µs making 1 call to Class::MOP::Object::meta
511);
512
513Class::MOP::Attribute->meta->add_method('clone' => sub {
514 my $self = shift;
515 $self->meta->clone_object($self, @_);
516120µs20µs});
# spent 116µs making 1 call to Class::MOP::Mixin::HasMethods::add_method # spent 18µs making 1 call to Class::MOP::Object::meta
517
518## --------------------------------------------------------
519## Class::MOP::Method
520129µs29µsClass::MOP::Method->meta->add_attribute(
# spent 479µs making 1 call to Class::MOP::Object::meta # spent 332µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 39µs making 1 call to Class::MOP::Attribute::new
521 Class::MOP::Attribute->new('body' => (
522 reader => { 'body' => \&Class::MOP::Method::body },
523 ))
524);
525
526122µs22µsClass::MOP::Method->meta->add_attribute(
# spent 321µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Object::meta
527 Class::MOP::Attribute->new('associated_metaclass' => (
528 reader => { 'associated_metaclass' => \&Class::MOP::Method::associated_metaclass },
529 ))
530);
531
532121µs21µsClass::MOP::Method->meta->add_attribute(
# spent 293µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
533 Class::MOP::Attribute->new('package_name' => (
534 reader => { 'package_name' => \&Class::MOP::Method::package_name },
535 ))
536);
537
538139µs39µsClass::MOP::Method->meta->add_attribute(
# spent 310µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Object::meta
539 Class::MOP::Attribute->new('name' => (
540 reader => { 'name' => \&Class::MOP::Method::name },
541 ))
542);
543
544133µs33µsClass::MOP::Method->meta->add_attribute(
# spent 469µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
545 Class::MOP::Attribute->new('original_method' => (
546 reader => { 'original_method' => \&Class::MOP::Method::original_method },
547 writer => { '_set_original_method' => \&Class::MOP::Method::_set_original_method },
548 ))
549);
550
551## --------------------------------------------------------
552## Class::MOP::Method::Wrapped
553
554# NOTE:
555# the way this item is initialized, this
556# really does not follow the standard
557# practices of attributes, but we put
558# it here for completeness
559124µs24µsClass::MOP::Method::Wrapped->meta->add_attribute(
# spent 479µs making 1 call to Class::MOP::Object::meta # spent 184µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 33µs making 1 call to Class::MOP::Attribute::new
560 Class::MOP::Attribute->new('modifier_table')
561);
562
563## --------------------------------------------------------
564## Class::MOP::Method::Generated
565
566129µs29µsClass::MOP::Method::Generated->meta->add_attribute(
# spent 508µs making 1 call to Class::MOP::Object::meta # spent 360µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 47µs making 1 call to Class::MOP::Attribute::new
567 Class::MOP::Attribute->new('is_inline' => (
568 reader => { 'is_inline' => \&Class::MOP::Method::Generated::is_inline },
569 default => 0,
570 ))
571);
572
573122µs22µsClass::MOP::Method::Generated->meta->add_attribute(
# spent 304µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 33µs making 1 call to Class::MOP::Attribute::new # spent 20µs making 1 call to Class::MOP::Object::meta
574 Class::MOP::Attribute->new('definition_context' => (
575 reader => { 'definition_context' => \&Class::MOP::Method::Generated::definition_context },
576 ))
577);
578
579
580## --------------------------------------------------------
581## Class::MOP::Method::Inlined
582
583132µs32µsClass::MOP::Method::Inlined->meta->add_attribute(
# spent 473µs making 1 call to Class::MOP::Object::meta # spent 345µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 30µs making 1 call to Class::MOP::Attribute::new
584 Class::MOP::Attribute->new('_expected_method_class' => (
585 reader => { '_expected_method_class' => \&Class::MOP::Method::Inlined::_expected_method_class },
586 ))
587);
588
589## --------------------------------------------------------
590## Class::MOP::Method::Accessor
591
592144µs44µsClass::MOP::Method::Accessor->meta->add_attribute(
# spent 443µs making 1 call to Class::MOP::Object::meta # spent 332µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 28µs making 1 call to Class::MOP::Attribute::new
593 Class::MOP::Attribute->new('attribute' => (
594 reader => {
595 'associated_attribute' => \&Class::MOP::Method::Accessor::associated_attribute
596 },
597 ))
598);
599
600121µs21µsClass::MOP::Method::Accessor->meta->add_attribute(
# spent 318µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 27µs making 1 call to Class::MOP::Attribute::new # spent 23µs making 1 call to Class::MOP::Object::meta
601 Class::MOP::Attribute->new('accessor_type' => (
602 reader => { 'accessor_type' => \&Class::MOP::Method::Accessor::accessor_type },
603 ))
604);
605
606## --------------------------------------------------------
607## Class::MOP::Method::Constructor
608
609Class::MOP::Method::Constructor->meta->add_attribute(
610 Class::MOP::Attribute->new('options' => (
611 reader => {
612 'options' => \&Class::MOP::Method::Constructor::options
613 },
614 default => sub { +{} }
615131µs31µs ))
# spent 496µs making 1 call to Class::MOP::Object::meta # spent 365µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 52µs making 1 call to Class::MOP::Attribute::new
616);
617
618131µs31µsClass::MOP::Method::Constructor->meta->add_attribute(
# spent 318µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 29µs making 1 call to Class::MOP::Attribute::new # spent 24µs making 1 call to Class::MOP::Object::meta
619 Class::MOP::Attribute->new('associated_metaclass' => (
620 init_arg => "metaclass", # FIXME alias and rename
621 reader => {
622 'associated_metaclass' => \&Class::MOP::Method::Constructor::associated_metaclass
623 },
624 ))
625);
626
627## --------------------------------------------------------
628## Class::MOP::Instance
629
630# NOTE:
631# these don't yet do much of anything, but are just
632# included for completeness
633
634126µs26µsClass::MOP::Instance->meta->add_attribute(
# spent 455µs making 1 call to Class::MOP::Object::meta # spent 343µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 34µs making 1 call to Class::MOP::Attribute::new
635 Class::MOP::Attribute->new('associated_metaclass',
636 reader => { associated_metaclass => \&Class::MOP::Instance::associated_metaclass },
637 ),
638);
639
640127µs27µsClass::MOP::Instance->meta->add_attribute(
# spent 318µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 32µs making 1 call to Class::MOP::Attribute::new # spent 19µs making 1 call to Class::MOP::Object::meta
641 Class::MOP::Attribute->new('_class_name',
642 init_arg => undef,
643 reader => { _class_name => \&Class::MOP::Instance::_class_name },
644 #lazy => 1, # not yet supported by Class::MOP but out our version does it anyway
645 #default => sub { $_[0]->associated_metaclass->name },
646 ),
647);
648
649126µs26µsClass::MOP::Instance->meta->add_attribute(
# spent 317µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 36µs making 1 call to Class::MOP::Attribute::new # spent 22µs making 1 call to Class::MOP::Object::meta
650 Class::MOP::Attribute->new('attributes',
651 reader => { attributes => \&Class::MOP::Instance::get_all_attributes },
652 ),
653);
654
655145µs45µsClass::MOP::Instance->meta->add_attribute(
# spent 311µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 28µs making 1 call to Class::MOP::Object::meta # spent 27µs making 1 call to Class::MOP::Attribute::new
656 Class::MOP::Attribute->new('slots',
657 reader => { slots => \&Class::MOP::Instance::slots },
658 ),
659);
660
661126µs26µsClass::MOP::Instance->meta->add_attribute(
# spent 299µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute # spent 32µs making 1 call to Class::MOP::Attribute::new # spent 18µs making 1 call to Class::MOP::Object::meta
662 Class::MOP::Attribute->new('slot_hash',
663 reader => { slot_hash => \&Class::MOP::Instance::slot_hash },
664 ),
665);
666
667## --------------------------------------------------------
668## Class::MOP::Object
669
670# need to replace the meta method there with a real meta method object
671131µs31µsClass::MOP::Object->meta->_add_meta_method('meta');
# spent 1.95ms making 1 call to Class::MOP::Mixin::HasMethods::_add_meta_method # spent 23µs making 1 call to Class::MOP::Object::meta
672
673## --------------------------------------------------------
674## Class::MOP::Mixin
675
676# need to replace the meta method there with a real meta method object
677125µs25µsClass::MOP::Mixin->meta->_add_meta_method('meta');
# spent 880µs making 1 call to Class::MOP::Mixin::HasMethods::_add_meta_method # spent 24µs making 1 call to Class::MOP::Mixin::meta
678
6791129µs129µsrequire Class::MOP::Deprecated unless our $no_deprecated;
680
681# we need the meta instance of the meta instance to be created now, in order
682# for the constructor to be able to use it
683119µs19µsClass::MOP::Instance->meta->get_meta_instance;
# spent 240µs making 1 call to Class::MOP::Class::get_meta_instance # spent 33µs making 1 call to Class::MOP::Object::meta
684
685# pretend the add_method never happenned. it hasn't yet affected anything
686110µs10µsundef Class::MOP::Instance->meta->{_package_cache_flag};
# spent 22µs making 1 call to Class::MOP::Object::meta
687
688## --------------------------------------------------------
689## Now close all the Class::MOP::* classes
690
691# NOTE: we don't need to inline the the accessors this only lengthens
692# the compile time of the MOP, and gives us no actual benefits.
693
694$_->meta->make_immutable(
695 inline_constructor => 0,
696 constructor_name => "_new",
697 inline_accessors => 0,
69819µs9µs) for qw/
# spent 25.5ms making 13 calls to Class::MOP::Class::make_immutable, avg 1.96ms/call # spent 263µs making 13 calls to Class::MOP::Object::meta, avg 20µs/call
699 Class::MOP::Package
700 Class::MOP::Module
701 Class::MOP::Class
702
703 Class::MOP::Attribute
704 Class::MOP::Method
705 Class::MOP::Instance
706
707 Class::MOP::Object
708
709 Class::MOP::Method::Generated
710 Class::MOP::Method::Inlined
711
712 Class::MOP::Method::Accessor
713 Class::MOP::Method::Constructor
714 Class::MOP::Method::Wrapped
715
716 Class::MOP::Method::Meta
7171300ns300ns/;
718
719$_->meta->make_immutable(
720 inline_constructor => 0,
721 constructor_name => undef,
722 inline_accessors => 0,
72317µs7µs) for qw/
# spent 712µs making 4 calls to Class::MOP::Class::make_immutable, avg 178µs/call # spent 72µs making 4 calls to Class::MOP::Mixin::meta, avg 18µs/call
724 Class::MOP::Mixin
725 Class::MOP::Mixin::AttributeCore
726 Class::MOP::Mixin::HasAttributes
727 Class::MOP::Mixin::HasMethods
7281167µs167µs/;
729
7301245µs245µs1;
731
732__END__
733
734=pod
735
736=head1 NAME
737
738Class::MOP - A Meta Object Protocol for Perl 5
739
740=head1 DESCRIPTION
741
742This module is a fully functioning meta object protocol for the
743Perl 5 object system. It makes no attempt to change the behavior or
744characteristics of the Perl 5 object system, only to create a
745protocol for its manipulation and introspection.
746
747That said, it does attempt to create the tools for building a rich set
748of extensions to the Perl 5 object system. Every attempt has been made
749to abide by the spirit of the Perl 5 object system that we all know
750and love.
751
752This documentation is sparse on conceptual details. We suggest looking
753at the items listed in the L<SEE ALSO> section for more
754information. In particular the book "The Art of the Meta Object
755Protocol" was very influential in the development of this system.
756
757=head2 What is a Meta Object Protocol?
758
759A meta object protocol is an API to an object system.
760
761To be more specific, it abstracts the components of an object system
762(classes, object, methods, object attributes, etc.). These
763abstractions can then be used to inspect and manipulate the object
764system which they describe.
765
766It can be said that there are two MOPs for any object system; the
767implicit MOP and the explicit MOP. The implicit MOP handles things
768like method dispatch or inheritance, which happen automatically as
769part of how the object system works. The explicit MOP typically
770handles the introspection/reflection features of the object system.
771
772All object systems have implicit MOPs. Without one, they would not
773work. Explicit MOPs are much less common, and depending on the
774language can vary from restrictive (Reflection in Java or C#) to wide
775open (CLOS is a perfect example).
776
777=head2 Yet Another Class Builder! Why?
778
779This is B<not> a class builder so much as a I<class builder
780B<builder>>. The intent is that an end user will not use this module
781directly, but instead this module is used by module authors to build
782extensions and features onto the Perl 5 object system.
783
784This system is used by L<Moose>, which supplies a powerful class
785builder system built entirely on top of C<Class::MOP>.
786
787=head2 Who is this module for?
788
789This module is for anyone who has ever created or wanted to create a
790module for the Class:: namespace. The tools which this module provides
791make doing complex Perl 5 wizardry simpler, by removing such barriers
792as the need to hack symbol tables, or understand the fine details of
793method dispatch.
794
795=head2 What changes do I have to make to use this module?
796
797This module was designed to be as unintrusive as possible. Many of its
798features are accessible without B<any> change to your existing
799code. It is meant to be a compliment to your existing code and not an
800intrusion on your code base. Unlike many other B<Class::> modules,
801this module B<does not> require you subclass it, or even that you
802C<use> it in within your module's package.
803
804The only features which requires additions to your code are the
805attribute handling and instance construction features, and these are
806both completely optional features. The only reason for this is because
807Perl 5's object system does not actually have these features built
808in. More information about this feature can be found below.
809
810=head2 About Performance
811
812It is a common misconception that explicit MOPs are a performance hit.
813This is not a universal truth, it is a side-effect of some specific
814implementations. For instance, using Java reflection is slow because
815the JVM cannot take advantage of any compiler optimizations, and the
816JVM has to deal with much more runtime type information as well.
817
818Reflection in C# is marginally better as it was designed into the
819language and runtime (the CLR). In contrast, CLOS (the Common Lisp
820Object System) was built to support an explicit MOP, and so
821performance is tuned for it.
822
823This library in particular does its absolute best to avoid putting
824B<any> drain at all upon your code's performance. In fact, by itself
825it does nothing to affect your existing code. So you only pay for what
826you actually use.
827
828=head2 About Metaclass compatibility
829
830This module makes sure that all metaclasses created are both upwards
831and downwards compatible. The topic of metaclass compatibility is
832highly esoteric and is something only encountered when doing deep and
833involved metaclass hacking. There are two basic kinds of metaclass
834incompatibility; upwards and downwards.
835
836Upwards metaclass compatibility means that the metaclass of a
837given class is either the same as (or a subclass of) all of the
838class's ancestors.
839
840Downward metaclass compatibility means that the metaclasses of a
841given class's ancestors are all either the same as (or a subclass
842of) that metaclass.
843
844Here is a diagram showing a set of two classes (C<A> and C<B>) and
845two metaclasses (C<Meta::A> and C<Meta::B>) which have correct
846metaclass compatibility both upwards and downwards.
847
848 +---------+ +---------+
849 | Meta::A |<----| Meta::B | <....... (instance of )
850 +---------+ +---------+ <------- (inherits from)
851 ^ ^
852 : :
853 +---------+ +---------+
854 | A |<----| B |
855 +---------+ +---------+
856
857In actuality, I<all> of a class's metaclasses must be compatible,
858not just the class metaclass. That includes the instance, attribute,
859and method metaclasses, as well as the constructor and destructor
860classes.
861
862C<Class::MOP> will attempt to fix some simple types of
863incompatibilities. If all the metaclasses for the parent class are
864I<subclasses> of the child's metaclasses then we can simply replace
865the child's metaclasses with the parent's. In addition, if the child
866is missing a metaclass that the parent has, we can also just make the
867child use the parent's metaclass.
868
869As I said this is a highly esoteric topic and one you will only run
870into if you do a lot of subclassing of L<Class::MOP::Class>. If you
871are interested in why this is an issue see the paper I<Uniform and
872safe metaclass composition> linked to in the L<SEE ALSO> section of
873this document.
874
875=head2 Using custom metaclasses
876
877Always use the L<metaclass> pragma when using a custom metaclass, this
878will ensure the proper initialization order and not accidentally
879create an incorrect type of metaclass for you. This is a very rare
880problem, and one which can only occur if you are doing deep metaclass
881programming. So in other words, don't worry about it.
882
883Note that if you're using L<Moose> we encourage you to I<not> use
884L<metaclass> pragma, and instead use L<Moose::Util::MetaRole> to apply
885roles to a class's metaclasses. This topic is covered at length in
886various L<Moose::Cookbook> recipes.
887
888=head1 PROTOCOLS
889
890The meta-object protocol is divided into 4 main sub-protocols:
891
892=head2 The Class protocol
893
894This provides a means of manipulating and introspecting a Perl 5
895class. It handles symbol table hacking for you, and provides a rich
896set of methods that go beyond simple package introspection.
897
898See L<Class::MOP::Class> for more details.
899
900=head2 The Attribute protocol
901
902This provides a consistent representation for an attribute of a Perl 5
903class. Since there are so many ways to create and handle attributes in
904Perl 5 OO, the Attribute protocol provide as much of a unified
905approach as possible. Of course, you are always free to extend this
906protocol by subclassing the appropriate classes.
907
908See L<Class::MOP::Attribute> for more details.
909
910=head2 The Method protocol
911
912This provides a means of manipulating and introspecting methods in the
913Perl 5 object system. As with attributes, there are many ways to
914approach this topic, so we try to keep it pretty basic, while still
915making it possible to extend the system in many ways.
916
917See L<Class::MOP::Method> for more details.
918
919=head2 The Instance protocol
920
921This provides a layer of abstraction for creating object instances.
922Since the other layers use this protocol, it is relatively easy to
923change the type of your instances from the default hash reference to
924some other type of reference. Several examples are provided in the
925F<examples/> directory included in this distribution.
926
927See L<Class::MOP::Instance> for more details.
928
929=head1 FUNCTIONS
930
931Note that this module does not export any constants or functions.
932
933=head2 Constants
934
935=over 4
936
937=item I<Class::MOP::IS_RUNNING_ON_5_10>
938
939We set this constant depending on what version perl we are on, this
940allows us to take advantage of new 5.10 features and stay backwards
941compatible.
942
943=back
944
945=head2 Utility functions
946
947Note that these are all called as B<functions, not methods>.
948
949=over 4
950
951=item B<Class::MOP::load_class($class_name, \%options?)>
952
953This will load the specified C<$class_name>, if it is not already
954loaded (as reported by C<is_class_loaded>). This function can be used
955in place of tricks like C<eval "use $module"> or using C<require>
956unconditionally.
957
958If the module cannot be loaded, an exception is thrown.
959
960You can pass a hash reference with options as second argument. The
961only option currently recognised is C<-version>, which will ensure
962that the loaded class has at least the required version.
963
964See also L</Class Loading Options>.
965
966For historical reasons, this function explicitly returns a true value.
967
968=item B<Class::MOP::is_class_loaded($class_name, \%options?)>
969
970Returns a boolean indicating whether or not C<$class_name> has been
971loaded.
972
973This does a basic check of the symbol table to try and determine as
974best it can if the C<$class_name> is loaded, it is probably correct
975about 99% of the time, but it can be fooled into reporting false
976positives. In particular, loading any of the core L<IO> modules will
977cause most of the rest of the core L<IO> modules to falsely report
978having been loaded, due to the way the base L<IO> module works.
979
980You can pass a hash reference with options as second argument. The
981only option currently recognised is C<-version>, which will ensure
982that the loaded class has at least the required version.
983
984See also L</Class Loading Options>.
985
986=item B<Class::MOP::get_code_info($code)>
987
988This function returns two values, the name of the package the C<$code>
989is from and the name of the C<$code> itself. This is used by several
990elements of the MOP to determine where a given C<$code> reference is
991from.
992
993=item B<Class::MOP::class_of($instance_or_class_name)>
994
995This will return the metaclass of the given instance or class name. If the
996class lacks a metaclass, no metaclass will be initialized, and C<undef> will be
997returned.
998
999=item B<Class::MOP::check_package_cache_flag($pkg)>
1000
1001B<NOTE: DO NOT USE THIS FUNCTION, IT IS FOR INTERNAL USE ONLY!>
1002
1003This will return an integer that is managed by L<Class::MOP::Class> to
1004determine if a module's symbol table has been altered.
1005
1006In Perl 5.10 or greater, this flag is package specific. However in
1007versions prior to 5.10, this will use the C<PL_sub_generation>
1008variable which is not package specific.
1009
1010=item B<Class::MOP::load_first_existing_class(@class_names)>
1011
1012=item B<Class::MOP::load_first_existing_class($classA, \%optionsA?, $classB, ...)>
1013
1014B<NOTE: DO NOT USE THIS FUNCTION, IT IS FOR INTERNAL USE ONLY!>
1015
1016Given a list of class names, this function will attempt to load each
1017one in turn.
1018
1019If it finds a class it can load, it will return that class' name. If
1020none of the classes can be loaded, it will throw an exception.
1021
1022Additionally, you can pass a hash reference with options after each
1023class name. Currently, only C<-version> is recognised and will ensure
1024that the loaded class has at least the required version. If the class
1025version is not sufficient, an exception will be raised.
1026
1027See also L</Class Loading Options>.
1028
1029=back
1030
1031=head2 Metaclass cache functions
1032
1033Class::MOP holds a cache of metaclasses. The following are functions
1034(B<not methods>) which can be used to access that cache. It is not
1035recommended that you mess with these. Bad things could happen, but if
1036you are brave and willing to risk it: go for it!
1037
1038=over 4
1039
1040=item B<Class::MOP::get_all_metaclasses>
1041
1042This will return a hash of all the metaclass instances that have
1043been cached by L<Class::MOP::Class>, keyed by the package name.
1044
1045=item B<Class::MOP::get_all_metaclass_instances>
1046
1047This will return a list of all the metaclass instances that have
1048been cached by L<Class::MOP::Class>.
1049
1050=item B<Class::MOP::get_all_metaclass_names>
1051
1052This will return a list of all the metaclass names that have
1053been cached by L<Class::MOP::Class>.
1054
1055=item B<Class::MOP::get_metaclass_by_name($name)>
1056
1057This will return a cached L<Class::MOP::Class> instance, or nothing
1058if no metaclass exists with that C<$name>.
1059
1060=item B<Class::MOP::store_metaclass_by_name($name, $meta)>
1061
1062This will store a metaclass in the cache at the supplied C<$key>.
1063
1064=item B<Class::MOP::weaken_metaclass($name)>
1065
1066In rare cases (e.g. anonymous metaclasses) it is desirable to
1067store a weakened reference in the metaclass cache. This
1068function will weaken the reference to the metaclass stored
1069in C<$name>.
1070
1071=item B<Class::MOP::does_metaclass_exist($name)>
1072
1073This will return true of there exists a metaclass stored in the
1074C<$name> key, and return false otherwise.
1075
1076=item B<Class::MOP::remove_metaclass_by_name($name)>
1077
1078This will remove the metaclass stored in the C<$name> key.
1079
1080=back
1081
1082=head2 Class Loading Options
1083
1084=over 4
1085
1086=item -version
1087
1088Can be used to pass a minimum required version that will be checked
1089against the class version after it was loaded.
1090
1091=back
1092
1093=head1 SEE ALSO
1094
1095=head2 Books
1096
1097There are very few books out on Meta Object Protocols and Metaclasses
1098because it is such an esoteric topic. The following books are really
1099the only ones I have found. If you know of any more, B<I<please>>
1100email me and let me know, I would love to hear about them.
1101
1102=over 4
1103
1104=item I<The Art of the Meta Object Protocol>
1105
1106=item I<Advances in Object-Oriented Metalevel Architecture and Reflection>
1107
1108=item I<Putting MetaClasses to Work>
1109
1110=item I<Smalltalk: The Language>
1111
1112=back
1113
1114=head2 Papers
1115
1116=over 4
1117
1118=item "Uniform and safe metaclass composition"
1119
1120An excellent paper by the people who brought us the original Traits paper.
1121This paper is on how Traits can be used to do safe metaclass composition,
1122and offers an excellent introduction section which delves into the topic of
1123metaclass compatibility.
1124
1125L<http://www.iam.unibe.ch/~scg/Archive/Papers/Duca05ySafeMetaclassTrait.pdf>
1126
1127=item "Safe Metaclass Programming"
1128
1129This paper seems to precede the above paper, and propose a mix-in based
1130approach as opposed to the Traits based approach. Both papers have similar
1131information on the metaclass compatibility problem space.
1132
1133L<http://citeseer.ist.psu.edu/37617.html>
1134
1135=back
1136
1137=head2 Prior Art
1138
1139=over 4
1140
1141=item The Perl 6 MetaModel work in the Pugs project
1142
1143=over 4
1144
1145=item L<http://svn.openfoundry.org/pugs/misc/Perl-MetaModel/>
1146
1147=item L<http://github.com/perl6/p5-modules/tree/master/Perl6-ObjectSpace/>
1148
1149=back
1150
1151=back
1152
1153=head2 Articles
1154
1155=over 4
1156
1157=item CPAN Module Review of Class::MOP
1158
1159L<http://www.oreillynet.com/onlamp/blog/2006/06/cpan_module_review_classmop.html>
1160
1161=back
1162
1163=head1 SIMILAR MODULES
1164
1165As I have said above, this module is a class-builder-builder, so it is
1166not the same thing as modules like L<Class::Accessor> and
1167L<Class::MethodMaker>. That being said there are very few modules on CPAN
1168with similar goals to this module. The one I have found which is most
1169like this module is L<Class::Meta>, although it's philosophy and the MOP it
1170creates are very different from this modules.
1171
1172=head1 BUGS
1173
1174All complex software has bugs lurking in it, and this module is no
1175exception.
1176
1177Please report any bugs to C<bug-class-mop@rt.cpan.org>, or through the
1178web interface at L<http://rt.cpan.org>.
1179
1180You can also discuss feature requests or possible bugs on the Moose
1181mailing list (moose@perl.org) or on IRC at
1182L<irc://irc.perl.org/#moose>.
1183
1184=head1 ACKNOWLEDGEMENTS
1185
1186=over 4
1187
1188=item Rob Kinyon
1189
1190Thanks to Rob for actually getting the development of this module kick-started.
1191
1192=back
1193
1194=head1 AUTHORS
1195
1196Stevan Little E<lt>stevan@iinteractive.comE<gt>
1197
1198B<with contributions from:>
1199
1200Brandon (blblack) Black
1201
1202Florian (rafl) Ragwitz
1203
1204Guillermo (groditi) Roditi
1205
1206Dave (autarch) Rolsky
1207
1208Matt (mst) Trout
1209
1210Rob (robkinyon) Kinyon
1211
1212Yuval (nothingmuch) Kogman
1213
1214Scott (konobi) McWhirter
1215
1216Dylan Hardison
1217
1218=head1 COPYRIGHT AND LICENSE
1219
1220Copyright 2006-2010 by Infinity Interactive, Inc.
1221
1222L<http://www.iinteractive.com>
1223
1224This library is free software; you can redistribute it and/or modify
1225it under the same terms as Perl itself.
1226
1227=cut
# spent 2.35ms within Class::MOP::get_code_info which was called 573 times, avg 4µs/call: # 393 times (1.55ms+0s) by Class::MOP::Mixin::HasMethods::add_method at line 84 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/HasMethods.pm, avg 4µs/call # 178 times (790µs+0s) by Class::MOP::Mixin::HasMethods::_code_is_mine at line 100 of /usr/local/lib/perl/5.10.0/Class/MOP/Mixin/HasMethods.pm, avg 4µs/call # 2 times (10µs+0s) by Moose::Exporter::_make_sub_exporter_params at line 206 of /usr/local/lib/perl/5.10.0/Moose/Exporter.pm, avg 5µs/call
sub Class::MOP::get_code_info; # xsub
# spent 924µs within Class::MOP::is_class_loaded which was called 129 times, avg 7µs/call: # 71 times (517µs+0s) by Class::MOP::load_first_existing_class at line 107 of /usr/local/lib/perl/5.10.0/Class/MOP.pm, avg 7µs/call # 58 times (406µs+0s) by Class::MOP::Class::_immutable_metaclass at line 1205 of /usr/local/lib/perl/5.10.0/Class/MOP/Class.pm, avg 7µs/call
sub Class::MOP::is_class_loaded; # xsub