File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP/Package.pm |
Statements Executed | 21188 |
Statement Execution Time | 27.7ms |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
2227 | 3 | 2 | 14.3ms | 21.6ms | get_package_symbol | Class::MOP::Package::
1276 | 4 | 4 | 6.96ms | 6.98ms | add_package_symbol | Class::MOP::Package::
2271 | 3 | 2 | 4.31ms | 4.31ms | namespace | Class::MOP::Package::
3554 | 34 | 18 | 2.15ms | 2.15ms | name (xsub) | Class::MOP::Package::
27 | 2 | 2 | 526µs | 2.18ms | initialize | Class::MOP::Package::
10 | 1 | 1 | 105µs | 174µs | has_package_symbol | Class::MOP::Package::
2 | 1 | 1 | 87µs | 2.62ms | reinitialize | Class::MOP::Package::
5 | 1 | 1 | 70µs | 70µs | _new | Class::MOP::Package::
20 | 2 | 1 | 68µs | 68µs | _deconstruct_variable_name | Class::MOP::Package::
1 | 1 | 1 | 14µs | 16µs | BEGIN@4 | Class::MOP::Package::
1 | 1 | 1 | 9µs | 22µs | BEGIN@100 | Class::MOP::Package::
1 | 1 | 1 | 9µs | 29µs | BEGIN@146 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 91µs | BEGIN@14 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 18µs | BEGIN@207 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 31µs | BEGIN@8 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 15µs | BEGIN@5 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 17µs | BEGIN@152 | Class::MOP::Package::
1 | 1 | 1 | 7µs | 17µs | BEGIN@145 | Class::MOP::Package::
1 | 1 | 1 | 6µs | 41µs | BEGIN@7 | Class::MOP::Package::
0 | 0 | 0 | 0s | 0s | list_all_package_symbols | Class::MOP::Package::
0 | 0 | 0 | 0s | 0s | remove_package_glob | Class::MOP::Package::
0 | 0 | 0 | 0s | 0s | remove_package_symbol | Class::MOP::Package::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | |||||
2 | package Class::MOP::Package; | ||||
3 | |||||
4 | 3 | 20µs | 2 | 19µs | # spent 16µs (14+3) within Class::MOP::Package::BEGIN@4 which was called
# once (14µs+3µs) by base::import at line 4 # spent 16µs making 1 call to Class::MOP::Package::BEGIN@4
# spent 3µs making 1 call to strict::import |
5 | 3 | 20µs | 2 | 24µs | # spent 15µs (7+9) within Class::MOP::Package::BEGIN@5 which was called
# once (7µs+9µs) by base::import at line 5 # spent 15µs making 1 call to Class::MOP::Package::BEGIN@5
# spent 9µs making 1 call to warnings::import |
6 | |||||
7 | 3 | 23µs | 2 | 75µs | # spent 41µs (6+34) within Class::MOP::Package::BEGIN@7 which was called
# once (6µs+34µs) by base::import at line 7 # spent 41µs making 1 call to Class::MOP::Package::BEGIN@7
# spent 34µs making 1 call to Exporter::import |
8 | 3 | 50µs | 2 | 55µs | # spent 31µs (7+24) within Class::MOP::Package::BEGIN@8 which was called
# once (7µs+24µs) by base::import at line 8 # spent 31µs making 1 call to Class::MOP::Package::BEGIN@8
# spent 24µs making 1 call to Exporter::import |
9 | |||||
10 | 1 | 700ns | our $VERSION = '0.98'; | ||
11 | 1 | 14µs | $VERSION = eval $VERSION; | ||
12 | 1 | 300ns | our $AUTHORITY = 'cpan:STEVAN'; | ||
13 | |||||
14 | 3 | 224µs | 2 | 91µs | # spent 91µs (7+84) within Class::MOP::Package::BEGIN@14 which was called
# once (7µs+84µs) by base::import at line 14 # spent 91µs making 1 call to Class::MOP::Package::BEGIN@14
# spent 84µs making 1 call to base::import, recursion: max depth 2, time 84µs |
15 | |||||
16 | # creation ... | ||||
17 | |||||
18 | # spent 2.18ms (526µs+1.66) within Class::MOP::Package::initialize which was called 27 times, avg 81µs/call:
# 22 times (416µs+1.57ms) by Moose::Meta::Role::initialize at line 158 of Moose/Meta/Role.pm, avg 90µs/call
# 5 times (109µs+87µs) by Moose::Exporter::build_import_methods at line 79 of Moose/Exporter.pm, avg 39µs/call | ||||
19 | 27 | 38µs | my ( $class, @args ) = @_; | ||
20 | |||||
21 | 27 | 42µs | unshift @args, "package" if @args % 2; | ||
22 | |||||
23 | 27 | 45µs | my %options = @args; | ||
24 | 27 | 18µs | my $package_name = $options{package}; | ||
25 | |||||
26 | |||||
27 | # we hand-construct the class | ||||
28 | # until we can bootstrap it | ||||
29 | 27 | 30µs | 27 | 29µs | if ( my $meta = Class::MOP::get_metaclass_by_name($package_name) ) { # spent 29µs making 27 calls to Class::MOP::get_metaclass_by_name, avg 1µs/call |
30 | return $meta; | ||||
31 | } else { | ||||
32 | 27 | 137µs | 27 | 1.59ms | my $meta = ( ref $class || $class )->_new({ # spent 1.52ms making 22 calls to Moose::Meta::Role::_new, avg 69µs/call
# spent 70µs making 5 calls to Class::MOP::Package::_new, avg 14µs/call |
33 | 'package' => $package_name, | ||||
34 | %options, | ||||
35 | }); | ||||
36 | 27 | 31µs | 27 | 41µs | Class::MOP::store_metaclass_by_name($package_name, $meta); # spent 41µs making 27 calls to Class::MOP::store_metaclass_by_name, avg 2µs/call |
37 | |||||
38 | 27 | 85µs | return $meta; | ||
39 | } | ||||
40 | } | ||||
41 | |||||
42 | # spent 2.62ms (87µs+2.54) within Class::MOP::Package::reinitialize which was called 2 times, avg 1.31ms/call:
# 2 times (87µs+2.54ms) by Moose::Meta::Class::reinitialize at line 167 of Moose/Meta/Class.pm, avg 1.31ms/call | ||||
43 | 2 | 9µs | my ( $class, @args ) = @_; | ||
44 | |||||
45 | 2 | 10µs | unshift @args, "package" if @args % 2; | ||
46 | |||||
47 | 2 | 8µs | my %options = @args; | ||
48 | 2 | 3µs | my $package_name = delete $options{package}; | ||
49 | |||||
50 | 2 | 16µs | 3 | 4µs | (defined $package_name && $package_name # spent 2µs making 2 calls to Scalar::Util::blessed, avg 1µs/call
# spent 2µs making 1 call to UNIVERSAL::isa |
51 | && (!blessed $package_name || $package_name->isa('Class::MOP::Package'))) | ||||
52 | || confess "You must pass a package name or an existing Class::MOP::Package instance"; | ||||
53 | |||||
54 | 2 | 9µs | 3 | 2µs | $package_name = $package_name->name # spent 1µs making 2 calls to Scalar::Util::blessed, avg 500ns/call
# spent 500ns making 1 call to Class::MOP::Package::name |
55 | if blessed $package_name; | ||||
56 | |||||
57 | 2 | 4µs | 2 | 6µs | Class::MOP::remove_metaclass_by_name($package_name); # spent 6µs making 2 calls to Class::MOP::remove_metaclass_by_name, avg 3µs/call |
58 | |||||
59 | 2 | 29µs | 2 | 2.52ms | $class->initialize($package_name, %options); # call with first arg form for compat # spent 2.52ms making 2 calls to Moose::Meta::Class::initialize, avg 1.26ms/call |
60 | } | ||||
61 | |||||
62 | # spent 70µs within Class::MOP::Package::_new which was called 5 times, avg 14µs/call:
# 5 times (70µs+0s) by Class::MOP::Package::initialize at line 32, avg 14µs/call | ||||
63 | 5 | 4µs | my $class = shift; | ||
64 | |||||
65 | 5 | 3µs | return Class::MOP::Class->initialize($class)->new_object(@_) | ||
66 | if $class ne __PACKAGE__; | ||||
67 | |||||
68 | 5 | 6µs | my $params = @_ == 1 ? $_[0] : {@_}; | ||
69 | |||||
70 | 5 | 62µs | return bless { | ||
71 | package => $params->{package}, | ||||
72 | |||||
73 | # NOTE: | ||||
74 | # because of issues with the Perl API | ||||
75 | # to the typeglob in some versions, we | ||||
76 | # need to just always grab a new | ||||
77 | # reference to the hash in the accessor. | ||||
78 | # Ideally we could just store a ref and | ||||
79 | # it would Just Work, but oh well :\ | ||||
80 | |||||
81 | namespace => \undef, | ||||
82 | |||||
83 | } => $class; | ||||
84 | } | ||||
85 | |||||
86 | # Attributes | ||||
87 | |||||
88 | # NOTE: | ||||
89 | # all these attribute readers will be bootstrapped | ||||
90 | # away in the Class::MOP bootstrap section | ||||
91 | |||||
92 | # spent 4.31ms within Class::MOP::Package::namespace which was called 2271 times, avg 2µs/call:
# 2227 times (4.20ms+0s) by Class::MOP::Package::get_package_symbol at line 194, avg 2µs/call
# 34 times (92µs+0s) by Class::MOP::Mixin::HasMethods::get_method_list at line 151 of Class/MOP/Mixin/HasMethods.pm, avg 3µs/call
# 10 times (20µs+0s) by Class::MOP::Package::has_package_symbol at line 166, avg 2µs/call | ||||
93 | # NOTE: | ||||
94 | # because of issues with the Perl API | ||||
95 | # to the typeglob in some versions, we | ||||
96 | # need to just always grab a new | ||||
97 | # reference to the hash here. Ideally | ||||
98 | # we could just store a ref and it would | ||||
99 | # Just Work, but oh well :\ | ||||
100 | 3 | 146µs | 2 | 36µs | # spent 22µs (9+14) within Class::MOP::Package::BEGIN@100 which was called
# once (9µs+14µs) by base::import at line 100 # spent 22µs making 1 call to Class::MOP::Package::BEGIN@100
# spent 14µs making 1 call to strict::unimport |
101 | 2271 | 6.61ms | \%{$_[0]->{'package'} . '::'} | ||
102 | } | ||||
103 | |||||
104 | # utility methods | ||||
105 | |||||
106 | { | ||||
107 | 2 | 3µs | my %SIGIL_MAP = ( | ||
108 | '$' => 'SCALAR', | ||||
109 | '@' => 'ARRAY', | ||||
110 | '%' => 'HASH', | ||||
111 | '&' => 'CODE', | ||||
112 | ); | ||||
113 | |||||
114 | sub _deconstruct_variable_name { | ||||
115 | 20 | 8µs | my ($self, $variable) = @_; | ||
116 | |||||
117 | 20 | 4µs | (defined $variable) | ||
118 | || confess "You must pass a variable name"; | ||||
119 | |||||
120 | 20 | 12µs | my $sigil = substr($variable, 0, 1, ''); | ||
121 | |||||
122 | 20 | 1µs | (defined $sigil) | ||
123 | || confess "The variable name must include a sigil"; | ||||
124 | |||||
125 | 20 | 6µs | (exists $SIGIL_MAP{$sigil}) | ||
126 | || confess "I do not recognize that sigil '$sigil'"; | ||||
127 | |||||
128 | 20 | 51µs | return ($variable, $sigil, $SIGIL_MAP{$sigil}); | ||
129 | } | ||||
130 | } | ||||
131 | |||||
132 | # Class attributes | ||||
133 | |||||
134 | # ... these functions have to touch the symbol table itself,.. yuk | ||||
135 | |||||
136 | # spent 6.98ms (6.96+22µs) within Class::MOP::Package::add_package_symbol which was called 1276 times, avg 5µs/call:
# 727 times (4.08ms+0s) by Class::MOP::Mixin::HasMethods::add_method at line 70 of Class/MOP/Mixin/HasMethods.pm, avg 6µs/call
# 514 times (2.69ms+0s) by Class::MOP::Package::get_package_symbol at line 197, avg 5µs/call
# 25 times (122µs+0s) by Class::MOP::Class:::around at line 89 of Class/MOP/Class/Immutable/Trait.pm, avg 5µs/call
# 10 times (72µs+22µs) by Moose::Exporter::build_import_methods at line 85 of Moose/Exporter.pm, avg 9µs/call | ||||
137 | 1276 | 549µs | my ($self, $variable, $initial_value) = @_; | ||
138 | |||||
139 | my ($name, $sigil, $type) = ref $variable eq 'HASH' | ||||
140 | 1276 | 1.38ms | 10 | 22µs | ? @{$variable}{qw[name sigil type]} # spent 22µs making 10 calls to Class::MOP::Package::_deconstruct_variable_name, avg 2µs/call |
141 | : $self->_deconstruct_variable_name($variable); | ||||
142 | |||||
143 | 1276 | 381µs | my $pkg = $self->{'package'}; | ||
144 | |||||
145 | 3 | 29µs | 2 | 27µs | # spent 17µs (7+10) within Class::MOP::Package::BEGIN@145 which was called
# once (7µs+10µs) by base::import at line 145 # spent 17µs making 1 call to Class::MOP::Package::BEGIN@145
# spent 10µs making 1 call to strict::unimport |
146 | 3 | 59µs | 2 | 49µs | # spent 29µs (9+20) within Class::MOP::Package::BEGIN@146 which was called
# once (9µs+20µs) by base::import at line 146 # spent 29µs making 1 call to Class::MOP::Package::BEGIN@146
# spent 20µs making 1 call to warnings::unimport |
147 | 1276 | 5.30ms | *{$pkg . '::' . $name} = ref $initial_value ? $initial_value : \$initial_value; | ||
148 | } | ||||
149 | |||||
150 | sub remove_package_glob { | ||||
151 | my ($self, $name) = @_; | ||||
152 | 3 | 194µs | 2 | 27µs | # spent 17µs (7+10) within Class::MOP::Package::BEGIN@152 which was called
# once (7µs+10µs) by base::import at line 152 # spent 17µs making 1 call to Class::MOP::Package::BEGIN@152
# spent 10µs making 1 call to strict::unimport |
153 | delete ${$self->name . '::'}{$name}; | ||||
154 | } | ||||
155 | |||||
156 | # ... these functions deal with stuff on the namespace level | ||||
157 | |||||
158 | # spent 174µs (105+68) within Class::MOP::Package::has_package_symbol which was called 10 times, avg 17µs/call:
# 10 times (105µs+68µs) by Moose::Exporter::build_import_methods at line 83 of Moose/Exporter.pm, avg 17µs/call | ||||
159 | 10 | 6µs | my ( $self, $variable ) = @_; | ||
160 | |||||
161 | my ( $name, $sigil, $type ) | ||||
162 | = ref $variable eq 'HASH' | ||||
163 | 10 | 29µs | 10 | 46µs | ? @{$variable}{qw[name sigil type]} # spent 46µs making 10 calls to Class::MOP::Package::_deconstruct_variable_name, avg 5µs/call |
164 | : $self->_deconstruct_variable_name($variable); | ||||
165 | |||||
166 | 10 | 14µs | 10 | 20µs | my $namespace = $self->namespace; # spent 20µs making 10 calls to Class::MOP::Package::namespace, avg 2µs/call |
167 | |||||
168 | 10 | 22µs | return 0 unless exists $namespace->{$name}; | ||
169 | |||||
170 | 1 | 700ns | my $entry_ref = \$namespace->{$name}; | ||
171 | 1 | 5µs | 1 | 2µs | if ( reftype($entry_ref) eq 'GLOB' ) { # spent 2µs making 1 call to Scalar::Util::reftype |
172 | if ( $type eq 'SCALAR' ) { | ||||
173 | return defined( ${ *{$entry_ref}{SCALAR} } ); | ||||
174 | } | ||||
175 | else { | ||||
176 | 1 | 4µs | return defined( *{$entry_ref}{$type} ); | ||
177 | } | ||||
178 | } | ||||
179 | else { | ||||
180 | |||||
181 | # a symbol table entry can be -1 (stub), string (stub with prototype), | ||||
182 | # or reference (constant) | ||||
183 | return $type eq 'CODE'; | ||||
184 | } | ||||
185 | } | ||||
186 | |||||
187 | # spent 21.6ms (14.3+7.38) within Class::MOP::Package::get_package_symbol which was called 2227 times, avg 10µs/call:
# 1999 times (12.7ms+6.62ms) by Class::MOP::Mixin::HasMethods::get_method at line 101 of Class/MOP/Mixin/HasMethods.pm, avg 10µs/call
# 180 times (1.22ms+628µs) by Class::MOP::Class::superclasses at line 582 of Class/MOP/Class.pm, avg 10µs/call
# 48 times (324µs+126µs) by Class::MOP::Class::superclasses at line 563 of Class/MOP/Class.pm, avg 9µs/call | ||||
188 | 2227 | 649µs | my ($self, $variable) = @_; | ||
189 | |||||
190 | my ($name, $sigil, $type) = ref $variable eq 'HASH' | ||||
191 | 2227 | 2.10ms | ? @{$variable}{qw[name sigil type]} | ||
192 | : $self->_deconstruct_variable_name($variable); | ||||
193 | |||||
194 | 2227 | 1.78ms | 2227 | 4.20ms | my $namespace = $self->namespace; # spent 4.20ms making 2227 calls to Class::MOP::Package::namespace, avg 2µs/call |
195 | |||||
196 | # FIXME | ||||
197 | 2227 | 1.19ms | 539 | 3.18ms | $self->add_package_symbol($variable) # spent 2.69ms making 514 calls to Class::MOP::Package::add_package_symbol, avg 5µs/call
# spent 491µs making 25 calls to Class::MOP::Class::Immutable::Class::MOP::Class::add_package_symbol, avg 20µs/call |
198 | unless exists $namespace->{$name}; | ||||
199 | |||||
200 | 2227 | 687µs | my $entry_ref = \$namespace->{$name}; | ||
201 | |||||
202 | 2227 | 5.18ms | if ( ref($entry_ref) eq 'GLOB' ) { | ||
203 | return *{$entry_ref}{$type}; | ||||
204 | } | ||||
205 | else { | ||||
206 | if ( $type eq 'CODE' ) { | ||||
207 | 3 | 364µs | 2 | 29µs | # spent 18µs (7+11) within Class::MOP::Package::BEGIN@207 which was called
# once (7µs+11µs) by base::import at line 207 # spent 18µs making 1 call to Class::MOP::Package::BEGIN@207
# spent 11µs making 1 call to strict::unimport |
208 | return \&{ $self->name . '::' . $name }; | ||||
209 | } | ||||
210 | else { | ||||
211 | return undef; | ||||
212 | } | ||||
213 | } | ||||
214 | } | ||||
215 | |||||
216 | sub remove_package_symbol { | ||||
217 | my ($self, $variable) = @_; | ||||
218 | |||||
219 | my ($name, $sigil, $type) = ref $variable eq 'HASH' | ||||
220 | ? @{$variable}{qw[name sigil type]} | ||||
221 | : $self->_deconstruct_variable_name($variable); | ||||
222 | |||||
223 | # FIXME: | ||||
224 | # no doubt this is grossly inefficient and | ||||
225 | # could be done much easier and faster in XS | ||||
226 | |||||
227 | my ($scalar_desc, $array_desc, $hash_desc, $code_desc) = ( | ||||
228 | { sigil => '$', type => 'SCALAR', name => $name }, | ||||
229 | { sigil => '@', type => 'ARRAY', name => $name }, | ||||
230 | { sigil => '%', type => 'HASH', name => $name }, | ||||
231 | { sigil => '&', type => 'CODE', name => $name }, | ||||
232 | ); | ||||
233 | |||||
234 | my ($scalar, $array, $hash, $code); | ||||
235 | if ($type eq 'SCALAR') { | ||||
236 | $array = $self->get_package_symbol($array_desc) if $self->has_package_symbol($array_desc); | ||||
237 | $hash = $self->get_package_symbol($hash_desc) if $self->has_package_symbol($hash_desc); | ||||
238 | $code = $self->get_package_symbol($code_desc) if $self->has_package_symbol($code_desc); | ||||
239 | } | ||||
240 | elsif ($type eq 'ARRAY') { | ||||
241 | $scalar = $self->get_package_symbol($scalar_desc) if $self->has_package_symbol($scalar_desc); | ||||
242 | $hash = $self->get_package_symbol($hash_desc) if $self->has_package_symbol($hash_desc); | ||||
243 | $code = $self->get_package_symbol($code_desc) if $self->has_package_symbol($code_desc); | ||||
244 | } | ||||
245 | elsif ($type eq 'HASH') { | ||||
246 | $scalar = $self->get_package_symbol($scalar_desc) if $self->has_package_symbol($scalar_desc); | ||||
247 | $array = $self->get_package_symbol($array_desc) if $self->has_package_symbol($array_desc); | ||||
248 | $code = $self->get_package_symbol($code_desc) if $self->has_package_symbol($code_desc); | ||||
249 | } | ||||
250 | elsif ($type eq 'CODE') { | ||||
251 | $scalar = $self->get_package_symbol($scalar_desc) if $self->has_package_symbol($scalar_desc); | ||||
252 | $array = $self->get_package_symbol($array_desc) if $self->has_package_symbol($array_desc); | ||||
253 | $hash = $self->get_package_symbol($hash_desc) if $self->has_package_symbol($hash_desc); | ||||
254 | } | ||||
255 | else { | ||||
256 | confess "This should never ever ever happen"; | ||||
257 | } | ||||
258 | |||||
259 | $self->remove_package_glob($name); | ||||
260 | |||||
261 | $self->add_package_symbol($scalar_desc => $scalar) if defined $scalar; | ||||
262 | $self->add_package_symbol($array_desc => $array) if defined $array; | ||||
263 | $self->add_package_symbol($hash_desc => $hash) if defined $hash; | ||||
264 | $self->add_package_symbol($code_desc => $code) if defined $code; | ||||
265 | } | ||||
266 | |||||
267 | sub list_all_package_symbols { | ||||
268 | my ($self, $type_filter) = @_; | ||||
269 | |||||
270 | my $namespace = $self->namespace; | ||||
271 | return keys %{$namespace} unless defined $type_filter; | ||||
272 | |||||
273 | # NOTE: | ||||
274 | # or we can filter based on | ||||
275 | # type (SCALAR|ARRAY|HASH|CODE) | ||||
276 | if ( $type_filter eq 'CODE' ) { | ||||
277 | return grep { | ||||
278 | (ref($namespace->{$_}) | ||||
279 | ? (ref($namespace->{$_}) eq 'SCALAR') | ||||
280 | : (ref(\$namespace->{$_}) eq 'GLOB' | ||||
281 | && defined(*{$namespace->{$_}}{CODE}))); | ||||
282 | } keys %{$namespace}; | ||||
283 | } else { | ||||
284 | return grep { *{$namespace->{$_}}{$type_filter} } keys %{$namespace}; | ||||
285 | } | ||||
286 | } | ||||
287 | |||||
288 | 1 | 14µs | 1; | ||
289 | |||||
290 | __END__ | ||||
291 | |||||
292 | =pod | ||||
293 | |||||
294 | =head1 NAME | ||||
295 | |||||
296 | Class::MOP::Package - Package Meta Object | ||||
297 | |||||
298 | =head1 DESCRIPTION | ||||
299 | |||||
300 | The Package Protocol provides an abstraction of a Perl 5 package. A | ||||
301 | package is basically namespace, and this module provides methods for | ||||
302 | looking at and changing that namespace's symbol table. | ||||
303 | |||||
304 | =head1 METHODS | ||||
305 | |||||
306 | =over 4 | ||||
307 | |||||
308 | =item B<< Class::MOP::Package->initialize($package_name) >> | ||||
309 | |||||
310 | This method creates a new C<Class::MOP::Package> instance which | ||||
311 | represents specified package. If an existing metaclass object exists | ||||
312 | for the package, that will be returned instead. | ||||
313 | |||||
314 | =item B<< Class::MOP::Package->reinitialize($package) >> | ||||
315 | |||||
316 | This method forcibly removes any existing metaclass for the package | ||||
317 | before calling C<initialize>. In contrast to C<initialize>, you may | ||||
318 | also pass an existing C<Class::MOP::Package> instance instead of just | ||||
319 | a package name as C<$package>. | ||||
320 | |||||
321 | Do not call this unless you know what you are doing. | ||||
322 | |||||
323 | =item B<< $metapackage->name >> | ||||
324 | |||||
325 | This is returns the package's name, as passed to the constructor. | ||||
326 | |||||
327 | =item B<< $metapackage->namespace >> | ||||
328 | |||||
329 | This returns a hash reference to the package's symbol table. The keys | ||||
330 | are symbol names and the values are typeglob references. | ||||
331 | |||||
332 | =item B<< $metapackage->add_package_symbol($variable_name, $initial_value) >> | ||||
333 | |||||
334 | This method accepts a variable name and an optional initial value. The | ||||
335 | C<$variable_name> must contain a leading sigil. | ||||
336 | |||||
337 | This method creates the variable in the package's symbol table, and | ||||
338 | sets it to the initial value if one was provided. | ||||
339 | |||||
340 | =item B<< $metapackage->get_package_symbol($variable_name) >> | ||||
341 | |||||
342 | Given a variable name, this method returns the variable as a reference | ||||
343 | or undef if it does not exist. The C<$variable_name> must contain a | ||||
344 | leading sigil. | ||||
345 | |||||
346 | =item B<< $metapackage->has_package_symbol($variable_name) >> | ||||
347 | |||||
348 | Returns true if there is a package variable defined for | ||||
349 | C<$variable_name>. The C<$variable_name> must contain a leading sigil. | ||||
350 | |||||
351 | =item B<< $metapackage->remove_package_symbol($variable_name) >> | ||||
352 | |||||
353 | This will remove the package variable specified C<$variable_name>. The | ||||
354 | C<$variable_name> must contain a leading sigil. | ||||
355 | |||||
356 | =item B<< $metapackage->remove_package_glob($glob_name) >> | ||||
357 | |||||
358 | Given the name of a glob, this will remove that glob from the | ||||
359 | package's symbol table. Glob names do not include a sigil. Removing | ||||
360 | the glob removes all variables and subroutines with the specified | ||||
361 | name. | ||||
362 | |||||
363 | =item B<< $metapackage->list_all_package_symbols($type_filter) >> | ||||
364 | |||||
365 | This will list all the glob names associated with the current | ||||
366 | package. These names do not have leading sigils. | ||||
367 | |||||
368 | You can provide an optional type filter, which should be one of | ||||
369 | 'SCALAR', 'ARRAY', 'HASH', or 'CODE'. | ||||
370 | |||||
371 | =item B<< $metapackage->get_all_package_symbols($type_filter) >> | ||||
372 | |||||
373 | This works much like C<list_all_package_symbols>, but it returns a | ||||
374 | hash reference. The keys are glob names and the values are references | ||||
375 | to the value for that name. | ||||
376 | |||||
377 | =back | ||||
378 | |||||
379 | =head2 Method introspection and creation | ||||
380 | |||||
381 | These methods allow you to introspect a class's methods, as well as | ||||
382 | add, remove, or change methods. | ||||
383 | |||||
384 | Determining what is truly a method in a Perl 5 class requires some | ||||
385 | heuristics (aka guessing). | ||||
386 | |||||
387 | Methods defined outside the package with a fully qualified name (C<sub | ||||
388 | Package::name { ... }>) will be included. Similarly, methods named | ||||
389 | with a fully qualified name using L<Sub::Name> are also included. | ||||
390 | |||||
391 | However, we attempt to ignore imported functions. | ||||
392 | |||||
393 | Ultimately, we are using heuristics to determine what truly is a | ||||
394 | method in a class, and these heuristics may get the wrong answer in | ||||
395 | some edge cases. However, for most "normal" cases the heuristics work | ||||
396 | correctly. | ||||
397 | |||||
398 | =over 4 | ||||
399 | |||||
400 | =item B<< $metapackage->get_method($method_name) >> | ||||
401 | |||||
402 | This will return a L<Class::MOP::Method> for the specified | ||||
403 | C<$method_name>. If the class does not have the specified method, it | ||||
404 | returns C<undef> | ||||
405 | |||||
406 | =item B<< $metapackage->has_method($method_name) >> | ||||
407 | |||||
408 | Returns a boolean indicating whether or not the class defines the | ||||
409 | named method. It does not include methods inherited from parent | ||||
410 | classes. | ||||
411 | |||||
412 | =item B<< $metapackage->get_method_list >> | ||||
413 | |||||
414 | This will return a list of method I<names> for all methods defined in | ||||
415 | this class. | ||||
416 | |||||
417 | =item B<< $metapackage->add_method($method_name, $method) >> | ||||
418 | |||||
419 | This method takes a method name and a subroutine reference, and adds | ||||
420 | the method to the class. | ||||
421 | |||||
422 | The subroutine reference can be a L<Class::MOP::Method>, and you are | ||||
423 | strongly encouraged to pass a meta method object instead of a code | ||||
424 | reference. If you do so, that object gets stored as part of the | ||||
425 | class's method map directly. If not, the meta information will have to | ||||
426 | be recreated later, and may be incorrect. | ||||
427 | |||||
428 | If you provide a method object, this method will clone that object if | ||||
429 | the object's package name does not match the class name. This lets us | ||||
430 | track the original source of any methods added from other classes | ||||
431 | (notably Moose roles). | ||||
432 | |||||
433 | =item B<< $metapackage->remove_method($method_name) >> | ||||
434 | |||||
435 | Remove the named method from the class. This method returns the | ||||
436 | L<Class::MOP::Method> object for the method. | ||||
437 | |||||
438 | =item B<< $metapackage->method_metaclass >> | ||||
439 | |||||
440 | Returns the class name of the method metaclass, see | ||||
441 | L<Class::MOP::Method> for more information on the method metaclass. | ||||
442 | |||||
443 | =item B<< $metapackage->wrapped_method_metaclass >> | ||||
444 | |||||
445 | Returns the class name of the wrapped method metaclass, see | ||||
446 | L<Class::MOP::Method::Wrapped> for more information on the wrapped | ||||
447 | method metaclass. | ||||
448 | |||||
449 | =item B<< Class::MOP::Package->meta >> | ||||
450 | |||||
451 | This will return a L<Class::MOP::Class> instance for this class. | ||||
452 | |||||
453 | =back | ||||
454 | |||||
455 | =head1 AUTHORS | ||||
456 | |||||
457 | Stevan Little E<lt>stevan@iinteractive.comE<gt> | ||||
458 | |||||
459 | =head1 COPYRIGHT AND LICENSE | ||||
460 | |||||
461 | Copyright 2006-2010 by Infinity Interactive, Inc. | ||||
462 | |||||
463 | L<http://www.iinteractive.com> | ||||
464 | |||||
465 | This library is free software; you can redistribute it and/or modify | ||||
466 | it under the same terms as Perl itself. | ||||
467 | |||||
468 | =cut | ||||
# spent 2.15ms within Class::MOP::Package::name which was called 3554 times, avg 604ns/call:
# 775 times (365µs+0s) by Class::MOP::Mixin::HasMethods::add_method at line 45 of Class/MOP/Mixin/HasMethods.pm, avg 470ns/call
# 705 times (413µs+0s) by Class::MOP::Class::linearized_isa at line 609 of Class/MOP/Class.pm, avg 586ns/call
# 525 times (346µs+0s) by Class::MOP::Mixin::HasMethods::add_method at line 65 of Class/MOP/Mixin/HasMethods.pm, avg 658ns/call
# 301 times (157µs+0s) by Class::MOP::Mixin::HasMethods::_code_is_mine at line 80 of Class/MOP/Mixin/HasMethods.pm, avg 521ns/call
# 276 times (185µs+0s) by Class::MOP::Attribute::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP/Attribute.pm:340] at line 332 of Class/MOP/Attribute.pm, avg 670ns/call
# 191 times (123µs+0s) by Class::MOP::Class::is_anon_class at line 224 of Class/MOP/Class.pm, avg 646ns/call
# 154 times (75µs+0s) by Class::MOP::Class::clone_object at line 404 of Class/MOP/Class.pm, avg 488ns/call
# 141 times (76µs+0s) by Class::MOP::Mixin::HasMethods::wrap_method_body at line 31 of Class/MOP/Mixin/HasMethods.pm, avg 540ns/call
# 92 times (60µs+0s) by Class::MOP::Class::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP/Class.pm:678] at line 664 of Class/MOP/Class.pm, avg 648ns/call
# 65 times (111µs+0s) by Class::MOP::Class::new_object at line 349 of Class/MOP/Class.pm, avg 2µs/call
# 57 times (41µs+0s) by Class::MOP::Attribute::_process_accessors at line 310 of Class/MOP/Attribute.pm, avg 714ns/call
# 48 times (41µs+0s) by Class::MOP::Class::superclasses at line 569 of Class/MOP/Class.pm, avg 846ns/call
# 43 times (37µs+0s) by Class::MOP::Method::Inlined::can_be_inlined at line 35 of Class/MOP/Method/Inlined.pm, avg 867ns/call
# 37 times (25µs+0s) by Class::MOP::Class::_inline_constructor at line 1055 of Class/MOP/Class.pm, avg 670ns/call
# 31 times (17µs+0s) by Class::MOP::Method::Constructor::_generate_constructor_method_inline at line 109 of Class/MOP/Method/Constructor.pm, avg 561ns/call
# 27 times (15µs+0s) by Class::MOP::Class::class_precedence_list at line 614 of Class/MOP/Class.pm, avg 563ns/call
# 18 times (12µs+0s) by Class::MOP::Instance::_class_name at line 71 of Class/MOP/Instance.pm, avg 650ns/call
# 13 times (13µs+0s) by Moose::Meta::Role::Application::ToClass::check_role_exclusions at line 39 of Moose/Meta/Role/Application/ToClass.pm, avg 1µs/call
# 13 times (10µs+0s) by Moose::Meta::Role::Application::ToRole::check_role_exclusions at line 23 of Moose/Meta/Role/Application/ToRole.pm, avg 738ns/call
# 8 times (4µs+0s) by Class::MOP::Class::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP/Class.pm:678] at line 671 of Class/MOP/Class.pm, avg 512ns/call
# 6 times (4µs+0s) by Class::MOP::Class::_inline_destructor at line 1089 of Class/MOP/Class.pm, avg 633ns/call
# 6 times (4µs+0s) by Moose::Meta::Method::Constructor::_initialize_body at line 63 of Moose/Meta/Method/Constructor.pm, avg 600ns/call
# 5 times (2µs+0s) by Class::MOP::Module::_instantiate_module at line 59 of Class/MOP/Module.pm, avg 480ns/call
# 3 times (3µs+0s) by MooseX::ClassAttribute::Role::Meta::Class::_class_attribute_var_name at line 194 of MooseX/ClassAttribute/Role/Meta/Class.pm, avg 1µs/call
# 2 times (2µs+0s) by Class::MOP::Class::DESTROY at line 245 of Class/MOP/Class.pm, avg 900ns/call
# 2 times (2µs+0s) by Class::MOP::Class:::after at line 136 of MooseX/AttributeHelpers/Trait/Base.pm, avg 750ns/call
# 2 times (1µs+0s) by Class::MOP::Attribute::get_write_method_ref at line 209 of Class/MOP/Attribute.pm, avg 600ns/call
# 2 times (900ns+0s) by Moose::Meta::Role::Application::ToRole::apply_methods at line 77 of Moose/Meta/Role/Application/ToRole.pm, avg 450ns/call
# once (2µs+0s) by Moose::Meta::Class::_reinitialize_with at line 435 of Moose/Meta/Class.pm
# once (1µs+0s) by Moose::Util::MetaRole::_make_new_class at line 150 of Moose/Util/MetaRole.pm
# once (900ns+0s) by Moose::Meta::Attribute::interpolate_class at line 125 of Moose/Meta/Attribute.pm
# once (600ns+0s) by MooseX::ClassAttribute::Meta::Method::Accessor::_inline_check_lazy at line 99 of MooseX/ClassAttribute/Meta/Method/Accessor.pm
# once (600ns+0s) by Moose::Meta::Class::_reinitialize_with at line 418 of Moose/Meta/Class.pm
# once (500ns+0s) by Class::MOP::Package::reinitialize at line 54 of Class/MOP/Package.pm |