Profile of /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm

← Index
NYTProf Performance Profile «block view•line view•sub view»
For 05.Domain_and_Item.t
Run on Tue May 4 17:21:41 2010
Reported on Tue May 4 17:23:14 2010

File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm
Statements Executed | 8675
Statement Execution Time | 20.8ms

Subroutines — ordered by exclusive time
Calls | P | F | Exclusive Time | Inclusive Time | Subroutine
--- | --- | --- | --- | --- | ---
8 | 1 | 1 | 5.38ms | 664ms | Class::MOP::::__ANON__[:103]Class::MOP::__ANON__[:103]
3617 | 7 | 5 | 4.25ms | 4.25ms | Class::MOP::::get_metaclass_by_nameClass::MOP::get_metaclass_by_name
1 | 1 | 1 | 3.80ms | 20.9ms | Class::MOP::::BEGIN@18Class::MOP::BEGIN@18
148 | 2 | 2 | 1.76ms | 599ms | Class::MOP::::load_first_existing_classClass::MOP::load_first_existing_class
1 | 1 | 1 | 1.74ms | 1.95ms | Class::MOP::::BEGIN@19Class::MOP::BEGIN@19
1 | 1 | 1 | 1.56ms | 2.17ms | Class::MOP::::BEGIN@9Class::MOP::BEGIN@9
312 | 12 | 9 | 1.33ms | 1.49ms | Class::MOP::::class_ofClass::MOP::class_of
1032 | 3 | 3 | 1.21ms | 1.21ms | Class::MOP::::get_code_infoClass::MOP::get_code_info (xsub)
1 | 1 | 1 | 704µs | 2.30ms | Class::MOP::::BEGIN@15Class::MOP::BEGIN@15
218 | 3 | 4 | 699µs | 699µs | Class::MOP::::is_class_loadedClass::MOP::is_class_loaded (xsub)
1 | 1 | 1 | 693µs | 5.30ms | Class::MOP::::BEGIN@17Class::MOP::BEGIN@17
1 | 1 | 1 | 676µs | 898µs | Class::MOP::::BEGIN@13Class::MOP::BEGIN@13
156 | 2 | 2 | 667µs | 667µs | Class::MOP::::CORE:matchClass::MOP::CORE:match (opcode)
149 | 1 | 1 | 651µs | 997µs | Class::MOP::::_class_to_pmfileClass::MOP::_class_to_pmfile
155 | 2 | 2 | 642µs | 1.31ms | Class::MOP::::_is_valid_class_nameClass::MOP::_is_valid_class_name
146 | 7 | 5 | 582µs | 599ms | Class::MOP::::load_classClass::MOP::load_class
1 | 1 | 1 | 505µs | 664µs | Class::MOP::::BEGIN@16Class::MOP::BEGIN@16
149 | 1 | 2 | 346µs | 346µs | Class::MOP::::CORE:substClass::MOP::CORE:subst (opcode)
119 | 3 | 3 | 208µs | 208µs | Class::MOP::::store_metaclass_by_nameClass::MOP::store_metaclass_by_name
88 | 2 | 2 | 149µs | 149µs | Class::MOP::::__ANON__[:494]Class::MOP::__ANON__[:494]
54 | 2 | 2 | 91µs | 91µs | Class::MOP::::__ANON__[:305]Class::MOP::__ANON__[:305]
54 | 2 | 2 | 87µs | 87µs | Class::MOP::::__ANON__[:286]Class::MOP::__ANON__[:286]
54 | 2 | 2 | 82µs | 82µs | Class::MOP::::__ANON__[:260]Class::MOP::__ANON__[:260]
54 | 2 | 2 | 79µs | 79µs | Class::MOP::::__ANON__[:218]Class::MOP::__ANON__[:218]
54 | 2 | 2 | 78µs | 78µs | Class::MOP::::__ANON__[:176]Class::MOP::__ANON__[:176]
32 | 1 | 1 | 69µs | 69µs | Class::MOP::::__ANON__[:321]Class::MOP::__ANON__[:321]
27 | 1 | 2 | 21µs | 21µs | Class::MOP::::__ANON__Class::MOP::__ANON__ (xsub)
1 | 1 | 2 | 17µs | 17µs | Class::MOP::::CORE:regcompClass::MOP::CORE:regcomp (opcode)
1 | 1 | 1 | 15µs | 15µs | Class::MOP::::BEGIN@7Class::MOP::BEGIN@7
1 | 1 | 1 | 14µs | 17µs | Class::MOP::::BEGIN@4Class::MOP::BEGIN@4
1 | 1 | 1 | 13µs | 21µs | Class::MOP::::BEGIN@5Class::MOP::BEGIN@5
1 | 1 | 1 | 11µs | 80µs | Class::MOP::::BEGIN@11Class::MOP::BEGIN@11
1 | 1 | 1 | 10µs | 29µs | Class::MOP::::__ANON__[:110]Class::MOP::__ANON__[:110]
1 | 1 | 1 | 10µs | 10µs | Class::MOP::::BEGIN@20Class::MOP::BEGIN@20
1 | 1 | 1 | 10µs | 47µs | Class::MOP::::BEGIN@12Class::MOP::BEGIN@12
2 | 1 | 1 | 9µs | 14µs | Class::MOP::::weaken_metaclassClass::MOP::weaken_metaclass
1 | 1 | 1 | 7µs | 7µs | Class::MOP::::BEGIN@22Class::MOP::BEGIN@22
2 | 1 | 1 | 6µs | 6µs | Class::MOP::::remove_metaclass_by_nameClass::MOP::remove_metaclass_by_name
0 | 0 | 0 | 0s | 0s | Class::MOP::::__ANON__[:501]Class::MOP::__ANON__[:501]
0 | 0 | 0 | 0s | 0s | Class::MOP::::__ANON__[:541]Class::MOP::__ANON__[:541]
0 | 0 | 0 | 0s | 0s | Class::MOP::::__ANON__[:606]Class::MOP::__ANON__[:606]
0 | 0 | 0 | 0s | 0s | Class::MOP::::does_metaclass_existClass::MOP::does_metaclass_exist
0 | 0 | 0 | 0s | 0s | Class::MOP::::get_all_metaclass_instancesClass::MOP::get_all_metaclass_instances
0 | 0 | 0 | 0s | 0s | Class::MOP::::get_all_metaclass_namesClass::MOP::get_all_metaclass_names
0 | 0 | 0 | 0s | 0s | Class::MOP::::get_all_metaclassesClass::MOP::get_all_metaclasses

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

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