| File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm |
| Statements Executed | 1991 |
| Statement Execution Time | 7.78ms |
| Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
|---|---|---|---|---|---|
| 1 | 1 | 1 | 11.3ms | 11.8ms | Class::MOP::BEGIN@9 |
| 1 | 1 | 1 | 3.93ms | 81.1ms | Class::MOP::BEGIN@18 |
| 1 | 1 | 1 | 1.80ms | 2.10ms | Class::MOP::BEGIN@13 |
| 1 | 1 | 1 | 1.69ms | 1.92ms | Class::MOP::BEGIN@19 |
| 994 | 6 | 4 | 1.06ms | 1.06ms | Class::MOP::get_metaclass_by_name |
| 1 | 1 | 1 | 865µs | 1.02ms | Class::MOP::BEGIN@16 |
| 1 | 1 | 1 | 732µs | 23.4ms | Class::MOP::BEGIN@17 |
| 1 | 1 | 1 | 719µs | 2.90ms | Class::MOP::BEGIN@15 |
| 1 | 1 | 1 | 639µs | 778µs | Class::MOP::__ANON__[:103] |
| 411 | 3 | 3 | 467µs | 467µs | Class::MOP::get_code_info (xsub) |
| 37 | 1 | 1 | 421µs | 1.86ms | Class::MOP::load_first_existing_class |
| 88 | 2 | 3 | 219µs | 219µs | Class::MOP::is_class_loaded (xsub) |
| 39 | 1 | 2 | 177µs | 177µs | Class::MOP::CORE:match (opcode) |
| 39 | 2 | 2 | 164µs | 341µs | Class::MOP::_is_valid_class_name |
| 37 | 1 | 1 | 158µs | 248µs | Class::MOP::_class_to_pmfile |
| 37 | 5 | 3 | 128µs | 1.99ms | Class::MOP::load_class |
| 63 | 2 | 2 | 104µs | 104µs | Class::MOP::store_metaclass_by_name |
| 37 | 1 | 2 | 91µs | 91µs | Class::MOP::CORE:subst (opcode) |
| 15 | 4 | 4 | 68µs | 76µs | Class::MOP::class_of |
| 1 | 1 | 1 | 15µs | 15µs | Class::MOP::BEGIN@7 |
| 1 | 1 | 1 | 13µs | 16µs | Class::MOP::BEGIN@4 |
| 1 | 1 | 1 | 13µs | 13µs | Class::MOP::BEGIN@20 |
| 1 | 1 | 1 | 12µs | 63µs | Class::MOP::BEGIN@12 |
| 1 | 1 | 1 | 11µs | 72µs | Class::MOP::BEGIN@11 |
| 5 | 2 | 2 | 9µs | 9µs | Class::MOP::__ANON__[:494] |
| 1 | 1 | 1 | 7µs | 7µs | Class::MOP::BEGIN@22 |
| 1 | 1 | 1 | 6µs | 14µs | Class::MOP::BEGIN@5 |
| 2 | 1 | 1 | 5µs | 5µs | Class::MOP::__ANON__[:321] |
| 2 | 1 | 1 | 4µs | 4µs | Class::MOP::__ANON__[:286] |
| 2 | 1 | 1 | 4µs | 4µs | Class::MOP::__ANON__[:176] |
| 2 | 1 | 1 | 4µs | 4µs | Class::MOP::__ANON__[:218] |
| 2 | 1 | 1 | 4µs | 4µs | Class::MOP::__ANON__[:260] |
| 2 | 1 | 1 | 4µs | 4µs | Class::MOP::__ANON__[:305] |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::__ANON__[:110] |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::__ANON__[:501] |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::__ANON__[:541] |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::__ANON__[:606] |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::does_metaclass_exist |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::get_all_metaclass_instances |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::get_all_metaclass_names |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::get_all_metaclasses |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::remove_metaclass_by_name |
| 0 | 0 | 0 | 0s | 0s | Class::MOP::weaken_metaclass |
| Line | State ments |
Time on line |
Calls | Time in subs |
Code |
|---|---|---|---|---|---|
| 1 | |||||
| 2 | package Class::MOP; | ||||
| 3 | |||||
| 4 | 3 | 20µs | 2 | 19µs | # spent 16µs (13+3) within Class::MOP::BEGIN@4 which was called
# once (13µs+3µs) by Moose::Exporter::BEGIN@11 at line 4 # spent 16µs making 1 call to Class::MOP::BEGIN@4
# spent 3µs making 1 call to strict::import |
| 5 | 3 | 17µs | 2 | 23µs | # spent 14µs (6+8) within Class::MOP::BEGIN@5 which was called
# once (6µs+8µs) by Moose::Exporter::BEGIN@11 at line 5 # spent 14µs making 1 call to Class::MOP::BEGIN@5
# spent 8µs making 1 call to warnings::import |
| 6 | |||||
| 7 | 3 | 30µ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 # spent 15µs making 1 call to Class::MOP::BEGIN@7 |
| 8 | |||||
| 9 | 3 | 141µs | 1 | 11.8ms | # spent 11.8ms (11.3+556µs) within Class::MOP::BEGIN@9 which was called
# once (11.3ms+556µs) by Moose::Exporter::BEGIN@11 at line 9 # spent 11.8ms making 1 call to Class::MOP::BEGIN@9 |
| 10 | |||||
| 11 | 3 | 37µs | 2 | 132µs | # spent 72µs (11+61) within Class::MOP::BEGIN@11 which was called
# once (11µs+61µs) by Moose::Exporter::BEGIN@11 at line 11 # spent 72µs making 1 call to Class::MOP::BEGIN@11
# spent 60µs making 1 call to Exporter::import |
| 12 | 3 | 36µs | 2 | 113µs | # spent 63µs (12+51) within Class::MOP::BEGIN@12 which was called
# once (12µs+51µs) by Moose::Exporter::BEGIN@11 at line 12 # spent 63µs making 1 call to Class::MOP::BEGIN@12
# spent 51µs making 1 call to Exporter::import |
| 13 | 3 | 269µs | 2 | 2.20ms | # spent 2.10ms (1.80+299µs) within Class::MOP::BEGIN@13 which was called
# once (1.80ms+299µs) by Moose::Exporter::BEGIN@11 at line 13 # spent 2.10ms making 1 call to Class::MOP::BEGIN@13
# spent 97µs making 1 call to Exporter::import |
| 14 | |||||
| 15 | 3 | 189µs | 1 | 2.90ms | # spent 2.90ms (719µs+2.19) within Class::MOP::BEGIN@15 which was called
# once (719µs+2.19ms) by Moose::Exporter::BEGIN@11 at line 15 # spent 2.90ms making 1 call to Class::MOP::BEGIN@15 |
| 16 | 3 | 102µs | 1 | 1.02ms | # spent 1.02ms (865µs+152µs) within Class::MOP::BEGIN@16 which was called
# once (865µs+152µs) by Moose::Exporter::BEGIN@11 at line 16 # spent 1.02ms making 1 call to Class::MOP::BEGIN@16 |
| 17 | 3 | 113µs | 1 | 23.4ms | # spent 23.4ms (732µs+22.7) within Class::MOP::BEGIN@17 which was called
# once (732µs+22.7ms) by Moose::Exporter::BEGIN@11 at line 17 # spent 23.4ms making 1 call to Class::MOP::BEGIN@17 |
| 18 | 3 | 114µs | 1 | 81.1ms | # spent 81.1ms (3.93+77.2) within Class::MOP::BEGIN@18 which was called
# once (3.93ms+77.2ms) by Moose::Exporter::BEGIN@11 at line 18 # spent 81.1ms making 1 call to Class::MOP::BEGIN@18 |
| 19 | 3 | 107µs | 1 | 1.92ms | # spent 1.92ms (1.69+224µs) within Class::MOP::BEGIN@19 which was called
# once (1.69ms+224µs) by Moose::Exporter::BEGIN@11 at line 19 # spent 1.92ms making 1 call to Class::MOP::BEGIN@19 |
| 20 | 3 | 66µs | 1 | 13µs | # spent 13µs within Class::MOP::BEGIN@20 which was called
# once (13µs+0s) by Moose::Exporter::BEGIN@11 at line 20 # spent 13µ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 | ||||
| 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.96ms | 1 | 7µs | } # spent 7µs making 1 call to Class::MOP::BEGIN@22 |
| 30 | |||||
| 31 | 1 | 700ns | our $VERSION = '0.98'; | ||
| 32 | 1 | 300ns | our $XS_VERSION = $VERSION; | ||
| 33 | 1 | 17µs | $VERSION = eval $VERSION; | ||
| 34 | 1 | 300ns | our $AUTHORITY = 'cpan:STEVAN'; | ||
| 35 | |||||
| 36 | 1 | 700ns | require XSLoader; | ||
| 37 | 1 | 305µs | 1 | 299µs | XSLoader::load( __PACKAGE__, $XS_VERSION ); # spent 299µ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 | 1µs | 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 | 994 | 1.80ms | # spent 1.06ms within Class::MOP::get_metaclass_by_name which was called 994 times, avg 1µs/call:
# 905 times (979µs+0s) by Class::MOP::Class::initialize at line 41 of Class/MOP/Class.pm, avg 1µs/call
# 61 times (54µs+0s) by Class::MOP::Class::_construct_class_instance at line 63 of Class/MOP/Class.pm, avg 879ns/call
# 24 times (24µs+0s) by Moose::Meta::Class::initialize at line 62 of Moose/Meta/Class.pm, avg 1µs/call
# 2 times (3µs+0s) by Class::MOP::Package::initialize at line 29 of Class/MOP/Package.pm, avg 2µs/call
# once (1µs+0s) by Moose::init_meta at line 160 of Moose.pm
# once (1µs+0s) by Class::MOP::Class::_check_metaclass_compatibility at line 179 of Class/MOP/Class.pm | ||
| 52 | 63 | 143µs | # spent 104µs within Class::MOP::store_metaclass_by_name which was called 63 times, avg 2µs/call:
# 61 times (102µs+0s) by Class::MOP::Class::_construct_class_instance at line 93 of Class/MOP/Class.pm, avg 2µs/call
# 2 times (3µs+0s) by Class::MOP::Package::initialize at line 36 of Class/MOP/Package.pm, avg 1µs/call | ||
| 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 76µs (68+8) within Class::MOP::class_of which was called 15 times, 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 3µs/call
# 4 times (26µs+3µ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 7µs/call
# once (7µs+700ns) by Moose::Meta::Class::superclasses at line 285 of Moose/Meta/Class.pm
# once (7µs+700ns) by Class::MOP::Object::_new at line 21 of Class/MOP/Object.pm | ||||
| 59 | 15 | 4µs | return unless defined $_[0]; | ||
| 60 | 15 | 45µs | 15 | 8µs | my $class = blessed($_[0]) || $_[0]; # spent 8µs making 15 calls to Scalar::Util::blessed, avg 520ns/call |
| 61 | 15 | 37µ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 248µs (158+91) within Class::MOP::_class_to_pmfile which was called 37 times, avg 7µs/call:
# 37 times (158µs+91µs) by Class::MOP::load_first_existing_class at line 95, avg 7µs/call | ||||
| 72 | 37 | 11µs | my $class = shift; | ||
| 73 | |||||
| 74 | 37 | 16µs | my $file = $class . '.pm'; | ||
| 75 | 37 | 156µs | 37 | 91µs | $file =~ s{::}{/}g; # spent 91µs making 37 calls to Class::MOP::CORE:subst, avg 2µs/call |
| 76 | |||||
| 77 | 37 | 72µs | return $file; | ||
| 78 | } | ||||
| 79 | |||||
| 80 | # spent 1.86ms (421µs+1.44) within Class::MOP::load_first_existing_class which was called 37 times, avg 50µs/call:
# 37 times (421µs+1.44ms) by Class::MOP::load_class at line 121, avg 50µs/call | ||||
| 81 | 37 | 38µs | my @classes = @_ | ||
| 82 | or return; | ||||
| 83 | |||||
| 84 | 37 | 30µs | foreach my $class (@classes) { | ||
| 85 | 37 | 62µs | 37 | 304µs | unless ( _is_valid_class_name($class) ) { # spent 304µs making 37 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 | 37 | 5µs | my $found; | ||
| 92 | 37 | 5µs | my %exceptions; | ||
| 93 | |||||
| 94 | 37 | 15µs | for my $class (@classes) { | ||
| 95 | 37 | 49µs | 37 | 248µs | my $file = _class_to_pmfile($class); # spent 248µs making 37 calls to Class::MOP::_class_to_pmfile, avg 7µs/call |
| 96 | |||||
| 97 | 37 | 231µs | 37 | 89µs | return $class if is_class_loaded($class);; # spent 89µs making 37 calls to Class::MOP::is_class_loaded, avg 2µs/call |
| 98 | |||||
| 99 | # spent 778µs (639+139) within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] which was called
# once (639µs+139µs) by Try::Tiny::try at line 71 of Try/Tiny.pm | ||||
| 100 | 1 | 3µs | local $SIG{__DIE__}; | ||
| 101 | 1 | 92µs | require $file; | ||
| 102 | 1 | 7µs | return 1; | ||
| 103 | } | ||||
| 104 | catch { | ||||
| 105 | unless (/^Can't locate \Q$file\E in \@INC/) { | ||||
| 106 | confess "Couldn't load class ($class) because: $_"; | ||||
| 107 | } | ||||
| 108 | |||||
| 109 | return; | ||||
| 110 | 1 | 11µs | 2 | 798µs | }; # spent 794µs making 1 call to Try::Tiny::try
# spent 4µs making 1 call to Try::Tiny::catch |
| 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 1.99ms (128µs+1.86) within Class::MOP::load_class which was called 37 times, avg 54µs/call:
# 32 times (104µs+890µs) by Class::MOP::Class::_inline_constructor at line 1053 of Class/MOP/Class.pm, avg 31µs/call
# 2 times (13µs+875µs) by Class::MOP::Class::_immutable_metaclass at line 966 of Class/MOP/Class.pm, avg 444µs/call
# once (5µs+39µs) by metaclass::import at line 27 of metaclass.pm
# once (3µs+32µs) by Moose::Meta::Class::superclasses at line 284 of Moose/Meta/Class.pm
# once (3µs+24µs) by Class::MOP::Class::_inline_destructor at line 1085 of Class/MOP/Class.pm | ||||
| 121 | 37 | 57µs | 37 | 1.86ms | load_first_existing_class($_[0]); # spent 1.86ms making 37 calls to Class::MOP::load_first_existing_class, avg 50µs/call |
| 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 | 37 | 67µs | return 1; | ||
| 127 | } | ||||
| 128 | |||||
| 129 | # spent 341µs (164+177) within Class::MOP::_is_valid_class_name which was called 39 times, avg 9µs/call:
# 37 times (146µs+158µs) by Class::MOP::load_first_existing_class at line 85, avg 8µs/call
# 2 times (17µs+20µs) by Class::MOP::Module::_instantiate_module at line 61 of Class/MOP/Module.pm, avg 18µs/call | ||||
| 130 | 39 | 11µs | my $class = shift; | ||
| 131 | |||||
| 132 | 39 | 6µs | return 0 if ref($class); | ||
| 133 | 39 | 4µs | return 0 unless defined($class); | ||
| 134 | 39 | 6µs | return 0 unless length($class); | ||
| 135 | |||||
| 136 | 39 | 325µs | 39 | 177µs | return 1 if $class =~ /^\w+(?:::\w+)*$/; # spent 177µs making 39 calls to Class::MOP::CORE:match, avg 5µ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 | 2 | 6µs | # spent 4µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:176] which was called 2 times, avg 2µs/call:
# 2 times (4µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 2µs/call | ||
| 177 | 1 | 18µs | 3 | 762µs | )) # spent 593µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 121µs making 1 call to Class::MOP::Mixin::meta
# spent 48µs making 1 call to Class::MOP::Attribute::new |
| 178 | ); | ||||
| 179 | |||||
| 180 | 1 | 6µs | 3 | 213µs | Class::MOP::Mixin::HasMethods->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 11µ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 | 201µs | Class::MOP::Mixin::HasMethods->meta->add_attribute( # spent 174µ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 |
| 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 | 2 | 6µs | # spent 4µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:218] which was called 2 times, avg 2µs/call:
# 2 times (4µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 2µs/call | ||
| 219 | 1 | 10µs | 3 | 261µs | )) # spent 185µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 47µs making 1 call to Class::MOP::Mixin::meta
# spent 29µs making 1 call to Class::MOP::Attribute::new |
| 220 | ); | ||||
| 221 | |||||
| 222 | 1 | 6µs | 3 | 206µs | Class::MOP::Mixin::HasAttributes->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 |
| 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 | 8µs | 3 | 240µs | Class::MOP::Package->meta->add_attribute( # spent 175µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 49µs making 1 call to Class::MOP::Object::meta
# spent 16µ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 | 2 | 6µs | # spent 4µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:260] which was called 2 times, avg 2µs/call:
# 2 times (4µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 2µs/call | ||
| 261 | 1 | 7µs | 3 | 215µs | )) # spent 182µ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::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 | 2 | 5µs | # spent 4µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:286] which was called 2 times, avg 2µs/call:
# 2 times (4µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 2µs/call | ||
| 287 | 1 | 10µs | 3 | 241µs | )) # spent 174µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 45µs making 1 call to Class::MOP::Object::meta
# spent 21µ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 | 2 | 6µs | # spent 4µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:305] which was called 2 times, avg 2µs/call:
# 2 times (4µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 2µs/call | ||
| 306 | 1 | 6µs | 3 | 203µs | )) # spent 171µ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 |
| 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 | 2 | 7µs | # spent 5µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:321] which was called 2 times, avg 3µs/call:
# 2 times (5µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 3µs/call | ||
| 322 | 1 | 10µs | 3 | 285µs | )) # spent 206µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 52µs making 1 call to Class::MOP::Object::meta
# spent 26µs making 1 call to Class::MOP::Attribute::new |
| 323 | ); | ||||
| 324 | |||||
| 325 | 1 | 5µs | 3 | 200µs | Class::MOP::Class->meta->add_attribute( # spent 172µ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 | 202µs | Class::MOP::Class->meta->add_attribute( # spent 174µ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 | 214µs | Class::MOP::Class->meta->add_attribute( # spent 187µ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 | 206µs | Class::MOP::Class->meta->add_attribute( # spent 178µ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 | 206µs | Class::MOP::Class->meta->add_attribute( # spent 174µ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 |
| 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 | 262µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 187µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 51µs making 1 call to Class::MOP::Mixin::meta
# spent 23µ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 | 282µ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 |
| 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 | 360µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 328µ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::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 | 7µs | 3 | 312µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 271µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 29µs making 1 call to Class::MOP::Attribute::new
# spent 12µ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 | 216µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 188µ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 |
| 420 | Class::MOP::Attribute->new('definition_context' => ( | ||||
| 421 | reader => { 'definition_context' => \&Class::MOP::Mixin::AttributeCore::definition_context }, | ||||
| 422 | )) | ||||
| 423 | ); | ||||
| 424 | |||||
| 425 | 1 | 7µ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 16µs making 1 call to Class::MOP::Attribute::new
# spent 11µ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 | 333µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 305µ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::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 | 315µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 285µ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 |
| 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 | 7µs | 3 | 295µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 265µ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 |
| 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 | 304µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 277µ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 |
| 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 | 220µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 193µ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 |
| 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 | 8µs | 3 | 373µs | Class::MOP::Mixin::AttributeCore->meta->add_attribute( # spent 343µ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 |
| 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 | 239µs | Class::MOP::Attribute->meta->add_attribute( # spent 176µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 48µ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 | 5 | 16µs | # spent 9µs within Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:494] which was called 5 times, avg 2µs/call:
# 4 times (7µ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
# once (2µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm | ||
| 495 | 1 | 7µs | 3 | 212µs | )) # spent 180µ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 |
| 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 | 66µs | }); # spent 54µ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 | 243µs | Class::MOP::Method->meta->add_attribute( # spent 177µ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 | 204µs | Class::MOP::Method->meta->add_attribute( # spent 177µ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 |
| 512 | Class::MOP::Attribute->new('associated_metaclass' => ( | ||||
| 513 | reader => { 'associated_metaclass' => \&Class::MOP::Method::associated_metaclass }, | ||||
| 514 | )) | ||||
| 515 | ); | ||||
| 516 | |||||
| 517 | 1 | 6µs | 3 | 220µs | Class::MOP::Method->meta->add_attribute( # spent 181µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 27µs making 1 call to Class::MOP::Attribute::new
# spent 12µ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 | 206µs | Class::MOP::Method->meta->add_attribute( # spent 179µ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 |
| 524 | Class::MOP::Attribute->new('name' => ( | ||||
| 525 | reader => { 'name' => \&Class::MOP::Method::name }, | ||||
| 526 | )) | ||||
| 527 | ); | ||||
| 528 | |||||
| 529 | 1 | 6µs | 3 | 303µs | Class::MOP::Method->meta->add_attribute( # spent 276µ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 | 12 | 4µs | my $self = shift; | ||
| 538 | 12 | 32µs | 24 | 1.52ms | my $clone = $self->meta->clone_object($self, @_); # spent 1.40ms making 12 calls to Class::MOP::Class::clone_object, avg 117µs/call
# spent 119µs making 12 calls to Class::MOP::Object::meta, avg 10µs/call |
| 539 | 12 | 14µs | 12 | 18µs | $clone->_set_original_method($self); # spent 18µs making 12 calls to Class::MOP::Method::_set_original_method, avg 1µs/call |
| 540 | 12 | 21µs | return $clone; | ||
| 541 | 1 | 5µs | 2 | 43µs | }); # spent 32µ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 | 165µs | Class::MOP::Method::Wrapped->meta->add_attribute( # spent 96µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 53µ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 | 9µs | 3 | 336µs | Class::MOP::Method::Generated->meta->add_attribute( # spent 274µ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 |
| 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 | 200µs | Class::MOP::Method::Generated->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 |
| 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 | 265µs | Class::MOP::Method::Inlined->meta->add_attribute( # spent 193µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 53µs making 1 call to Class::MOP::Object::meta
# spent 19µ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 | 9µs | 3 | 243µs | Class::MOP::Method::Accessor->meta->add_attribute( # spent 176µ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 |
| 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 | 219µs | Class::MOP::Method::Accessor->meta->add_attribute( # spent 181µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 23µs making 1 call to Class::MOP::Attribute::new
# spent 15µ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 | 280µs | )) # spent 200µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 53µs making 1 call to Class::MOP::Object::meta
# spent 27µs making 1 call to Class::MOP::Attribute::new |
| 608 | ); | ||||
| 609 | |||||
| 610 | 1 | 6µs | 3 | 200µs | Class::MOP::Method::Constructor->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 |
| 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 | 9µs | 3 | 254µs | Class::MOP::Instance->meta->add_attribute( # spent 192µ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 | 10µs | 3 | 257µs | Class::MOP::Instance->meta->add_attribute( # spent 207µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 30µs making 1 call to Class::MOP::Attribute::new
# spent 19µ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 | 227µs | Class::MOP::Instance->meta->add_attribute( # spent 198µ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 |
| 642 | Class::MOP::Attribute->new('attributes', | ||||
| 643 | reader => { attributes => \&Class::MOP::Instance::get_all_attributes }, | ||||
| 644 | ), | ||||
| 645 | ); | ||||
| 646 | |||||
| 647 | 1 | 10µs | 3 | 202µs | Class::MOP::Instance->meta->add_attribute( # spent 175µ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 | 9µ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 |
| 654 | Class::MOP::Attribute->new('slot_hash', | ||||
| 655 | reader => { slot_hash => \&Class::MOP::Instance::slot_hash }, | ||||
| 656 | ), | ||||
| 657 | ); | ||||
| 658 | |||||
| 659 | 1 | 114µ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 | 5µs | 2 | 233µs | Class::MOP::Instance->meta->get_meta_instance; # spent 214µs making 1 call to Class::MOP::Class::get_meta_instance
# spent 19µ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 | 10µs | undef Class::MOP::Instance->meta->{_package_cache_flag}; # spent 10µ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 | 38µs | 24 | 13.6ms | ) for qw/ # spent 13.5ms making 12 calls to Class::MOP::Class::make_immutable, avg 1.13ms/call
# spent 115µ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 | 0s | /; | ||
| 696 | |||||
| 697 | $_->meta->make_immutable( | ||||
| 698 | inline_constructor => 0, | ||||
| 699 | constructor_name => undef, | ||||
| 700 | inline_accessors => 0, | ||||
| 701 | 1 | 15µs | 8 | 498µs | ) for qw/ # spent 450µs making 4 calls to Class::MOP::Class::make_immutable, avg 113µs/call
# spent 47µs making 4 calls to Class::MOP::Mixin::meta, avg 12µ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 | 279µ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 177µs within Class::MOP::CORE:match which was called 39 times, avg 5µs/call:
# 39 times (177µs+0s) by Class::MOP::_is_valid_class_name at line 136 of Class/MOP.pm, avg 5µs/call | |||||
# spent 91µs within Class::MOP::CORE:subst which was called 37 times, avg 2µs/call:
# 37 times (91µs+0s) by Class::MOP::_class_to_pmfile at line 75 of Class/MOP.pm, avg 2µs/call | |||||
# spent 467µs within Class::MOP::get_code_info which was called 411 times, avg 1µs/call:
# 351 times (413µs+0s) by Class::MOP::Mixin::HasMethods::add_method at line 62 of Class/MOP/Mixin/HasMethods.pm, avg 1µs/call
# 58 times (52µs+0s) by Class::MOP::Mixin::HasMethods::_code_is_mine at line 78 of Class/MOP/Mixin/HasMethods.pm, avg 893ns/call
# 2 times (2µs+0s) by Moose::Exporter::_make_sub_exporter_params at line 177 of Moose/Exporter.pm, avg 1µs/call | |||||
# spent 219µs within Class::MOP::is_class_loaded which was called 88 times, avg 2µs/call:
# 51 times (130µs+0s) by Class::MOP::Class::_immutable_metaclass at line 949 of Class/MOP/Class.pm, avg 3µs/call
# 37 times (89µs+0s) by Class::MOP::load_first_existing_class at line 97 of Class/MOP.pm, avg 2µs/call |