blib/lib/Class/MOP.pm

filter: Statementstmt 99.3% 145 / 146 Branchbran 75.0% 6 / 8 Conditioncond 66.6% 2 / 3 MC/DCmcdc 0.0% 0 / 2 Subroutinesub 97.5% 39 / 40 Podpod 76.9% 10 / 13 totaltotal 95.2% 202 / 212 CC 5 SCAR 2.3
CC
5
Cov
97%
class_of
3.0
BEGIN
2.1
does_metaclass_exist
2.0
CRAP 1.3
« blib/lib/Moose/Meta/Method/Accessor/Native/String/substr.pm ↑ Summary blib/lib/Moose/Meta/Method/Accessor/Native/Number/abs.pm »
1 package Class::MOP;
2 459 our $VERSION = '2.4001';
3  
4 459 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 459 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 459 ▶use 5.008003;
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9 459 ▶use MRO::Compat;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 459 ▶use Class::Load 0.07 ();
Subroutine BEGIN: called CC=1 SCAR=0.0
11 459 ▶use Scalar::Util 'weaken', 'isweak', 'blessed';
Subroutine BEGIN: called CC=1 SCAR=0.0
12 459 ▶use Data::OptList;
Subroutine BEGIN: called CC=1 SCAR=0.0
13  
14 459 ▶use Class::MOP::Mixin::AttributeCore;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 459 ▶use Class::MOP::Mixin::HasAttributes;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 459 ▶use Class::MOP::Mixin::HasMethods;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 459 ▶use Class::MOP::Mixin::HasOverloads;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 459 ▶use Class::MOP::Class;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 459 ▶use Class::MOP::Attribute;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 459 ▶use Class::MOP::Method;
Subroutine BEGIN: called CC=1 SCAR=0.0
21  
22 459 ▶BEGIN {
Subroutine BEGIN: called CC=2 SCAR=7.2
23 *IS_RUNNING_ON_5_10 = ("$]" < 5.009_005)
24 ? sub () { 0 }
25 459 ▶ : sub () { 1 };
Branch: 1 branch
BranchTrueFalseTotal
"$]" < 5.009005 ? : 0 459 459
26  
27 # this is either part of core or set up appropriately by MRO::Compat
28 459 *check_package_cache_flag = \&mro::get_pkg_gen;
29 }
30  
31 459 XSLoader::load(
32 'Moose',
33 $VERSION,
34 );
35  
36 {
37 # Metaclasses are singletons, so we cache them here.
38 # there is no need to worry about destruction though
39 # because they should die only when the program dies.
40 # After all, do package definitions even get reaped?
41 # Anonymous classes manage their own destruction.
42 459 my %METAS;
43  
44 1 ▶ sub get_all_metaclasses { %METAS }
Subroutine get_all_metaclasses: called CC=1 SCAR=0.0
Pod documented
45 4 ▶ sub get_all_metaclass_instances { values %METAS }
Subroutine get_all_metaclass_instances: called CC=1 SCAR=0.0
Pod documented
46 1 ▶ sub get_all_metaclass_names { keys %METAS }
Subroutine get_all_metaclass_names: called CC=1 SCAR=0.0
Pod documented
47 759958 ▶ sub get_metaclass_by_name { $METAS{$_[0]} }
Subroutine get_metaclass_by_name: called CC=1 SCAR=0.0
Pod documented
48 32423 ▶ sub store_metaclass_by_name { $METAS{$_[0]} = $_[1] }
Subroutine store_metaclass_by_name: called CC=1 SCAR=0.0
Pod documented
49 117 ▶ sub weaken_metaclass { weaken($METAS{$_[0]}) }
Subroutine weaken_metaclass: called CC=1 SCAR=0.0
Pod documented
50 35724 ▶ sub metaclass_is_weak { isweak($METAS{$_[0]}) }
Subroutine metaclass_is_weak: called CC=1 SCAR=0.0
Pod documented
51 23061 ▶ sub does_metaclass_exist { exists $METAS{$_[0]} && defined $METAS{$_[0]} }
Subroutine does_metaclass_exist: called CC=2 SCAR=6.9
Pod documented
Branch: 1 branch
BranchTrueFalseTotal
exists $METAS{$_[0]} and defined $METAS{$_[0]} 22365 696 23061
52 251 ▶ sub remove_metaclass_by_name { delete $METAS{$_[0]}; return }
Subroutine remove_metaclass_by_name: called CC=1 SCAR=0.0
Pod documented
53  
54 # This handles instances as well as class names
55 38982 ▶ sub class_of {
Subroutine class_of: called CC=3 SCAR=11.0
Pod documented
56 38982 ▶ return unless defined $_[0];
Branch: 1 branch
BranchTrueFalseTotal
unless defined $_[0] 4 38978 38982
57 38978 ▶ my $class = blessed($_[0]) || $_[0];
Condition66%2/3
builtin::blessed($_[0]) || $_[0]
l!l&&r!l&&!r
406385720
MC/DC0%0/2
builtin::blessed($_[0]) || $_[0]
builtin::blessed($_[0]) $_[0]
Truth table66%2/3
A || B
A= builtin::blessed($_[0])B= $_[0]
ABresult
1X1
011
000
58 38978 return $METAS{$class};
59 }
60  
61 # NOTE:
62 # We only cache metaclasses, meaning instances of
63 # Class::MOP::Class. We do not cache instance of
64 # Class::MOP::Package or Class::MOP::Module. Mostly
65 # because I don't yet see a good reason to do so.
66 }
67  
68 459 ▶sub load_class {
Subroutine load_class: called CC=1 SCAR=0.0
Pod undocumented
69 1 Class::MOP::Deprecated::deprecated(
70 message => 'Class::MOP::load_class is deprecated',
71 feature => 'Class::Load wrapper functions',
72 );
73 1 require Class::Load;
74 1 goto &Class::Load::load_class;
75 }
76  
77 1 ▶sub load_first_existing_class {
Subroutine load_first_existing_class: called CC=1 SCAR=0.0
Pod undocumented
78 1 Class::MOP::Deprecated::deprecated(
79 message => 'Class::MOP::load_first_existing_class is deprecated',
80 feature => 'Class::Load wrapper functions',
81 );
82 1 require Class::Load;
83 1 goto &Class::Load::load_first_existing_class;
84 }
85  
86 1 ▶sub is_class_loaded {
Subroutine is_class_loaded: called CC=1 SCAR=0.0
Pod undocumented
87 1 Class::MOP::Deprecated::deprecated(
88 message => 'Class::MOP::is_class_loaded is deprecated',
89 feature => 'Class::Load wrapper functions',
90 );
91 1 require Class::Load;
92 1 goto &Class::Load::is_class_loaded;
93 }
94  
95 55446 ▶sub _definition_context {
Subroutine _definition_context: called CC=1 SCAR=0.0
96 55446 my %context;
97 55446 @context{qw(package file line)} = caller(0);
98  
99 return (
100 55446 definition_context => \%context,
101 );
102 }
103  
104 ## ----------------------------------------------------------------------------
105 ## Setting up our environment ...
106 ## ----------------------------------------------------------------------------
107 ## Class::MOP needs to have a few things in the global perl environment so
108 ## that it can operate effectively. Those things are done here.
109 ## ----------------------------------------------------------------------------
110  
111 # ... nothing yet actually ;)
112  
113 ## ----------------------------------------------------------------------------
114 ## Bootstrapping
115 ## ----------------------------------------------------------------------------
116 ## The code below here is to bootstrap our MOP with itself. This is also
117 ## sometimes called "tying the knot". By doing this, we make it much easier
118 ## to extend the MOP through subclassing and such since now you can use the
119 ## MOP itself to extend itself.
120 ##
121 ## Yes, I know, that's weird and insane, but it's a good thing, trust me :)
122 ## ----------------------------------------------------------------------------
123  
124 # We need to add in the meta-attributes here so that
125 # any subclass of Class::MOP::* will be able to
126 # inherit them using _construct_instance
127  
128 ## --------------------------------------------------------
129 ## Class::MOP::Mixin::HasMethods
130  
131 Class::MOP::Mixin::HasMethods->meta->add_attribute(
132 Class::MOP::Attribute->new('_methods' => (
133 reader => {
134 # NOTE:
135 # we just alias the original method
136 # rather than re-produce it here
137 '_method_map' => \&Class::MOP::Mixin::HasMethods::_method_map
138 },
139 4047 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
140 459 _definition_context(),
141 ))
142 );
143  
144 459 Class::MOP::Mixin::HasMethods->meta->add_attribute(
145 Class::MOP::Attribute->new('method_metaclass' => (
146 reader => {
147 # NOTE:
148 # we just alias the original method
149 # rather than re-produce it here
150 'method_metaclass' => \&Class::MOP::Mixin::HasMethods::method_metaclass
151 },
152 default => 'Class::MOP::Method',
153 _definition_context(),
154 ))
155 );
156  
157 459 Class::MOP::Mixin::HasMethods->meta->add_attribute(
158 Class::MOP::Attribute->new('wrapped_method_metaclass' => (
159 reader => {
160 # NOTE:
161 # we just alias the original method
162 # rather than re-produce it here
163 'wrapped_method_metaclass' => \&Class::MOP::Mixin::HasMethods::wrapped_method_metaclass
164 },
165 default => 'Class::MOP::Method::Wrapped',
166 _definition_context(),
167 ))
168 );
169  
170 ## --------------------------------------------------------
171 ## Class::MOP::Mixin::HasAttributes
172  
173 Class::MOP::Mixin::HasAttributes->meta->add_attribute(
174 Class::MOP::Attribute->new('attributes' => (
175 reader => {
176 # NOTE: we need to do this in order
177 # for the instance meta-object to
178 # not fall into meta-circular death
179 #
180 # we just alias the original method
181 # rather than re-produce it here
182 '_attribute_map' => \&Class::MOP::Mixin::HasAttributes::_attribute_map
183 },
184 4279 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
185 459 _definition_context(),
186 ))
187 );
188  
189 459 Class::MOP::Mixin::HasAttributes->meta->add_attribute(
190 Class::MOP::Attribute->new('attribute_metaclass' => (
191 reader => {
192 # NOTE:
193 # we just alias the original method
194 # rather than re-produce it here
195 'attribute_metaclass' => \&Class::MOP::Mixin::HasAttributes::attribute_metaclass
196 },
197 default => 'Class::MOP::Attribute',
198 _definition_context(),
199 ))
200 );
201  
202 ## --------------------------------------------------------
203 ## Class::MOP::Mixin::HasOverloads
204  
205 Class::MOP::Mixin::HasOverloads->meta->add_attribute(
206 Class::MOP::Attribute->new('_overload_map' => (
207 reader => {
208 '_overload_map' => \&Class::MOP::Mixin::HasOverloads::_overload_map
209 },
210 clearer => '_clear_overload_map',
211 4305 ▶ default => sub { {} },
Subroutine __ANON__: called CC=1 SCAR=0.0
212 459 _definition_context(),
213 ))
214 );
215  
216 ## --------------------------------------------------------
217 ## Class::MOP::Package
218  
219 459 Class::MOP::Package->meta->add_attribute(
220 Class::MOP::Attribute->new('package' => (
221 reader => {
222 # NOTE: we need to do this in order
223 # for the instance meta-object to
224 # not fall into meta-circular death
225 #
226 # we just alias the original method
227 # rather than re-produce it here
228 'name' => \&Class::MOP::Package::name
229 },
230 _definition_context(),
231 ))
232 );
233  
234 Class::MOP::Package->meta->add_attribute(
235 Class::MOP::Attribute->new('namespace' => (
236 reader => {
237 # NOTE:
238 # we just alias the original method
239 # rather than re-produce it here
240 'namespace' => \&Class::MOP::Package::namespace
241 },
242 init_arg => undef,
243 4341 ▶ default => sub { \undef },
Subroutine __ANON__: called CC=1 SCAR=0.0
244 459 _definition_context(),
245 ))
246 );
247  
248 ## --------------------------------------------------------
249 ## Class::MOP::Module
250  
251 # NOTE:
252 # yeah this is kind of stretching things a bit,
253 # but truthfully the version should be an attribute
254 # of the Module, the weirdness comes from having to
255 # stick to Perl 5 convention and store it in the
256 # $VERSION package variable. Basically if you just
257 # squint at it, it will look how you want it to look.
258 # Either as a package variable, or as a attribute of
259 # the metaclass, isn't abstraction great :)
260  
261 Class::MOP::Module->meta->add_attribute(
262 Class::MOP::Attribute->new('version' => (
263 reader => {
264 # NOTE:
265 # we just alias the original method
266 # rather than re-produce it here
267 'version' => \&Class::MOP::Module::version
268 },
269 init_arg => undef,
270 4341 ▶ default => sub { \undef },
Subroutine __ANON__: called CC=1 SCAR=0.0
271 459 _definition_context(),
272 ))
273 );
274  
275 # NOTE:
276 # By following the same conventions as version here,
277 # we are opening up the possibility that people can
278 # use the $AUTHORITY in non-Class::MOP modules as
279 # well.
280  
281 Class::MOP::Module->meta->add_attribute(
282 Class::MOP::Attribute->new('authority' => (
283 reader => {
284 # NOTE:
285 # we just alias the original method
286 # rather than re-produce it here
287 'authority' => \&Class::MOP::Module::authority
288 },
289 init_arg => undef,
290 4340 ▶ default => sub { \undef },
Subroutine __ANON__: called CC=1 SCAR=0.0
291 459 _definition_context(),
292 ))
293 );
294  
295 ## --------------------------------------------------------
296 ## Class::MOP::Class
297  
298 Class::MOP::Class->meta->add_attribute(
299 Class::MOP::Attribute->new('superclasses' => (
300 accessor => {
301 # NOTE:
302 # we just alias the original method
303 # rather than re-produce it here
304 'superclasses' => \&Class::MOP::Class::superclasses
305 },
306 init_arg => undef,
307 2769 ▶ default => sub { \undef },
Subroutine __ANON__: called CC=1 SCAR=0.0
308 459 _definition_context(),
309 ))
310 );
311  
312 459 Class::MOP::Class->meta->add_attribute(
313 Class::MOP::Attribute->new('instance_metaclass' => (
314 reader => {
315 # NOTE: we need to do this in order
316 # for the instance meta-object to
317 # not fall into meta-circular death
318 #
319 # we just alias the original method
320 # rather than re-produce it here
321 'instance_metaclass' => \&Class::MOP::Class::instance_metaclass
322 },
323 default => 'Class::MOP::Instance',
324 _definition_context(),
325 ))
326 );
327  
328 459 Class::MOP::Class->meta->add_attribute(
329 Class::MOP::Attribute->new('immutable_trait' => (
330 reader => {
331 'immutable_trait' => \&Class::MOP::Class::immutable_trait
332 },
333 default => "Class::MOP::Class::Immutable::Trait",
334 _definition_context(),
335 ))
336 );
337  
338 459 Class::MOP::Class->meta->add_attribute(
339 Class::MOP::Attribute->new('constructor_name' => (
340 reader => {
341 'constructor_name' => \&Class::MOP::Class::constructor_name,
342 },
343 default => "new",
344 _definition_context(),
345 ))
346 );
347  
348 459 Class::MOP::Class->meta->add_attribute(
349 Class::MOP::Attribute->new('constructor_class' => (
350 reader => {
351 'constructor_class' => \&Class::MOP::Class::constructor_class,
352 },
353 default => "Class::MOP::Method::Constructor",
354 _definition_context(),
355 ))
356 );
357  
358  
359 459 Class::MOP::Class->meta->add_attribute(
360 Class::MOP::Attribute->new('destructor_class' => (
361 reader => {
362 'destructor_class' => \&Class::MOP::Class::destructor_class,
363 },
364 _definition_context(),
365 ))
366 );
367  
368 # NOTE:
369 # we don't actually need to tie the knot with
370 # Class::MOP::Class here, it is actually handled
371 # within Class::MOP::Class itself in the
372 # _construct_class_instance method.
373  
374 ## --------------------------------------------------------
375 ## Class::MOP::Mixin::AttributeCore
376 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
377 Class::MOP::Attribute->new('name' => (
378 reader => {
379 # NOTE: we need to do this in order
380 # for the instance meta-object to
381 # not fall into meta-circular death
382 #
383 # we just alias the original method
384 # rather than re-produce it here
385 'name' => \&Class::MOP::Mixin::AttributeCore::name
386 },
387 _definition_context(),
388 ))
389 );
390  
391 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
392 Class::MOP::Attribute->new('accessor' => (
393 reader => { 'accessor' => \&Class::MOP::Mixin::AttributeCore::accessor },
394 predicate => { 'has_accessor' => \&Class::MOP::Mixin::AttributeCore::has_accessor },
395 _definition_context(),
396 ))
397 );
398  
399 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
400 Class::MOP::Attribute->new('reader' => (
401 reader => { 'reader' => \&Class::MOP::Mixin::AttributeCore::reader },
402 predicate => { 'has_reader' => \&Class::MOP::Mixin::AttributeCore::has_reader },
403 _definition_context(),
404 ))
405 );
406  
407 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
408 Class::MOP::Attribute->new('initializer' => (
409 reader => { 'initializer' => \&Class::MOP::Mixin::AttributeCore::initializer },
410 predicate => { 'has_initializer' => \&Class::MOP::Mixin::AttributeCore::has_initializer },
411 _definition_context(),
412 ))
413 );
414  
415 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
416 Class::MOP::Attribute->new('definition_context' => (
417 reader => { 'definition_context' => \&Class::MOP::Mixin::AttributeCore::definition_context },
418 _definition_context(),
419 ))
420 );
421  
422 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
423 Class::MOP::Attribute->new('writer' => (
424 reader => { 'writer' => \&Class::MOP::Mixin::AttributeCore::writer },
425 predicate => { 'has_writer' => \&Class::MOP::Mixin::AttributeCore::has_writer },
426 _definition_context(),
427 ))
428 );
429  
430 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
431 Class::MOP::Attribute->new('predicate' => (
432 reader => { 'predicate' => \&Class::MOP::Mixin::AttributeCore::predicate },
433 predicate => { 'has_predicate' => \&Class::MOP::Mixin::AttributeCore::has_predicate },
434 _definition_context(),
435 ))
436 );
437  
438 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
439 Class::MOP::Attribute->new('clearer' => (
440 reader => { 'clearer' => \&Class::MOP::Mixin::AttributeCore::clearer },
441 predicate => { 'has_clearer' => \&Class::MOP::Mixin::AttributeCore::has_clearer },
442 _definition_context(),
443 ))
444 );
445  
446 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
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 _definition_context(),
451 ))
452 );
453  
454 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
455 Class::MOP::Attribute->new('init_arg' => (
456 reader => { 'init_arg' => \&Class::MOP::Mixin::AttributeCore::init_arg },
457 predicate => { 'has_init_arg' => \&Class::MOP::Mixin::AttributeCore::has_init_arg },
458 _definition_context(),
459 ))
460 );
461  
462 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
463 Class::MOP::Attribute->new('default' => (
464 # default has a custom 'reader' method ...
465 predicate => { 'has_default' => \&Class::MOP::Mixin::AttributeCore::has_default },
466 _definition_context(),
467 ))
468 );
469  
470 459 Class::MOP::Mixin::AttributeCore->meta->add_attribute(
471 Class::MOP::Attribute->new('insertion_order' => (
472 reader => { 'insertion_order' => \&Class::MOP::Mixin::AttributeCore::insertion_order },
473 writer => { '_set_insertion_order' => \&Class::MOP::Mixin::AttributeCore::_set_insertion_order },
474 predicate => { 'has_insertion_order' => \&Class::MOP::Mixin::AttributeCore::has_insertion_order },
475 _definition_context(),
476 ))
477 );
478  
479 ## --------------------------------------------------------
480 ## Class::MOP::Attribute
481 459 Class::MOP::Attribute->meta->add_attribute(
482 Class::MOP::Attribute->new('associated_class' => (
483 reader => {
484 # NOTE: we need to do this in order
485 # for the instance meta-object to
486 # not fall into meta-circular death
487 #
488 # we just alias the original method
489 # rather than re-produce it here
490 'associated_class' => \&Class::MOP::Attribute::associated_class
491 },
492 _definition_context(),
493 ))
494 );
495  
496 Class::MOP::Attribute->meta->add_attribute(
497 Class::MOP::Attribute->new('associated_methods' => (
498 reader => { 'associated_methods' => \&Class::MOP::Attribute::associated_methods },
499 2686 ▶ default => sub { [] },
Subroutine __ANON__: called CC=1 SCAR=0.0
500 459 _definition_context(),
501 ))
502 );
503  
504 1 ▶Class::MOP::Attribute->meta->add_method('clone' => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
Subroutine clone: called CC=1 SCAR=0.0
505 1 my $self = shift;
506 1 $self->meta->clone_object($self, @_);
507 459 });
508  
509 ## --------------------------------------------------------
510 ## Class::MOP::Method
511 459 Class::MOP::Method->meta->add_attribute(
512 Class::MOP::Attribute->new('body' => (
513 reader => { 'body' => \&Class::MOP::Method::body },
514 _definition_context(),
515 ))
516 );
517  
518 459 Class::MOP::Method->meta->add_attribute(
519 Class::MOP::Attribute->new('associated_metaclass' => (
520 reader => { 'associated_metaclass' => \&Class::MOP::Method::associated_metaclass },
521 _definition_context(),
522 ))
523 );
524  
525 459 Class::MOP::Method->meta->add_attribute(
526 Class::MOP::Attribute->new('package_name' => (
527 reader => { 'package_name' => \&Class::MOP::Method::package_name },
528 _definition_context(),
529 ))
530 );
531  
532 459 Class::MOP::Method->meta->add_attribute(
533 Class::MOP::Attribute->new('name' => (
534 reader => { 'name' => \&Class::MOP::Method::name },
535 _definition_context(),
536 ))
537 );
538  
539 459 Class::MOP::Method->meta->add_attribute(
540 Class::MOP::Attribute->new('original_method' => (
541 reader => { 'original_method' => \&Class::MOP::Method::original_method },
542 writer => { '_set_original_method' => \&Class::MOP::Method::_set_original_method },
543 _definition_context(),
544 ))
545 );
546  
547 ## --------------------------------------------------------
548 ## Class::MOP::Method::Wrapped
549  
550 # NOTE:
551 # the way this item is initialized, this
552 # really does not follow the standard
553 # practices of attributes, but we put
554 # it here for completeness
555 459 Class::MOP::Method::Wrapped->meta->add_attribute(
556 Class::MOP::Attribute->new('modifier_table' => (
557 _definition_context(),
558 ))
559 );
560  
561 ## --------------------------------------------------------
562 ## Class::MOP::Method::Generated
563  
564 459 Class::MOP::Method::Generated->meta->add_attribute(
565 Class::MOP::Attribute->new('is_inline' => (
566 reader => { 'is_inline' => \&Class::MOP::Method::Generated::is_inline },
567 default => 0,
568 _definition_context(),
569 ))
570 );
571  
572 459 Class::MOP::Method::Generated->meta->add_attribute(
573 Class::MOP::Attribute->new('definition_context' => (
574 reader => { 'definition_context' => \&Class::MOP::Method::Generated::definition_context },
575 _definition_context(),
576 ))
577 );
578  
579  
580 ## --------------------------------------------------------
581 ## Class::MOP::Method::Inlined
582  
583 459 Class::MOP::Method::Inlined->meta->add_attribute(
584 Class::MOP::Attribute->new('_expected_method_class' => (
585 reader => { '_expected_method_class' => \&Class::MOP::Method::Inlined::_expected_method_class },
586 _definition_context(),
587 ))
588 );
589  
590 ## --------------------------------------------------------
591 ## Class::MOP::Method::Accessor
592  
593 459 Class::MOP::Method::Accessor->meta->add_attribute(
594 Class::MOP::Attribute->new('attribute' => (
595 reader => {
596 'associated_attribute' => \&Class::MOP::Method::Accessor::associated_attribute
597 },
598 _definition_context(),
599 ))
600 );
601  
602 459 Class::MOP::Method::Accessor->meta->add_attribute(
603 Class::MOP::Attribute->new('accessor_type' => (
604 reader => { 'accessor_type' => \&Class::MOP::Method::Accessor::accessor_type },
605 _definition_context(),
606 ))
607 );
608  
609 ## --------------------------------------------------------
610 ## Class::MOP::Method::Constructor
611  
612 Class::MOP::Method::Constructor->meta->add_attribute(
613 Class::MOP::Attribute->new('options' => (
614 reader => {
615 'options' => \&Class::MOP::Method::Constructor::options
616 },
617 0 ▶ default => sub { +{} },
Subroutine __ANON__: not called CC=1 SCAR=6.9
618 459 _definition_context(),
619 ))
620 );
621  
622 459 Class::MOP::Method::Constructor->meta->add_attribute(
623 Class::MOP::Attribute->new('associated_metaclass' => (
624 init_arg => "metaclass", # FIXME alias and rename
625 reader => {
626 'associated_metaclass' => \&Class::MOP::Method::Constructor::associated_metaclass
627 },
628 _definition_context(),
629 ))
630 );
631  
632 ## --------------------------------------------------------
633 ## Class::MOP::Overload
634  
635 459 Class::MOP::Overload->meta->add_attribute(
636 Class::MOP::Attribute->new(
637 'operator' => (
638 reader => { 'operator' => \&Class::MOP::Overload::operator },
639 required => 1,
640 _definition_context(),
641 )
642 )
643 );
644  
645 459 for my $attr (qw( method_name coderef coderef_package coderef_name method )) {
646 2295 Class::MOP::Overload->meta->add_attribute(
647 Class::MOP::Attribute->new(
648 $attr => (
649 reader => { $attr => Class::MOP::Overload->can($attr) },
650 predicate => {
651 'has_'
652 . $attr => Class::MOP::Overload->can( 'has_' . $attr )
653 },
654 _definition_context(),
655 )
656 )
657 );
658 }
659  
660 Class::MOP::Overload->meta->add_attribute(
661 459 Class::MOP::Attribute->new(
662 'associated_metaclass' => (
663 reader => {
664 'associated_metaclass' =>
665 \&Class::MOP::Overload::associated_metaclass
666 },
667 _definition_context(),
668 )
669 )
670 );
671  
672 ## --------------------------------------------------------
673 ## Class::MOP::Instance
674  
675 # NOTE:
676 # these don't yet do much of anything, but are just
677 # included for completeness
678  
679 459 Class::MOP::Instance->meta->add_attribute(
680 Class::MOP::Attribute->new('associated_metaclass',
681 reader => { associated_metaclass => \&Class::MOP::Instance::associated_metaclass },
682 _definition_context(),
683 ),
684 );
685  
686 459 Class::MOP::Instance->meta->add_attribute(
687 Class::MOP::Attribute->new('_class_name',
688 init_arg => undef,
689 reader => { _class_name => \&Class::MOP::Instance::_class_name },
690 #lazy => 1, # not yet supported by Class::MOP but out our version does it anyway
691 #default => sub { $_[0]->associated_metaclass->name },
692 _definition_context(),
693 ),
694 );
695  
696 459 Class::MOP::Instance->meta->add_attribute(
697 Class::MOP::Attribute->new('attributes',
698 reader => { attributes => \&Class::MOP::Instance::get_all_attributes },
699 _definition_context(),
700 ),
701 );
702  
703 459 Class::MOP::Instance->meta->add_attribute(
704 Class::MOP::Attribute->new('slots',
705 reader => { slots => \&Class::MOP::Instance::slots },
706 _definition_context(),
707 ),
708 );
709  
710 459 Class::MOP::Instance->meta->add_attribute(
711 Class::MOP::Attribute->new('slot_hash',
712 reader => { slot_hash => \&Class::MOP::Instance::slot_hash },
713 _definition_context(),
714 ),
715 );
716  
717 ## --------------------------------------------------------
718 ## Class::MOP::Object
719  
720 # need to replace the meta method there with a real meta method object
721 459 Class::MOP::Object->meta->_add_meta_method('meta');
722  
723 ## --------------------------------------------------------
724 ## Class::MOP::Mixin
725  
726 # need to replace the meta method there with a real meta method object
727 459 Class::MOP::Mixin->meta->_add_meta_method('meta');
728  
729 459 ▶require Class::MOP::Deprecated unless our $no_deprecated;
Branch: 1 branch
BranchTrueFalseTotal
unless our $no_deprecated 459 0 459
730  
731 # we need the meta instance of the meta instance to be created now, in order
732 # for the constructor to be able to use it
733 459 Class::MOP::Instance->meta->get_meta_instance;
734  
735 # pretend the add_method never happened. it hasn't yet affected anything
736 459 undef Class::MOP::Instance->meta->{_package_cache_flag};
737  
738 ## --------------------------------------------------------
739 ## Now close all the Class::MOP::* classes
740  
741 # NOTE: we don't need to inline the accessors this only lengthens the compile
742 # time of the MOP, and gives us no actual benefits.
743  
744 $_->meta->make_immutable(
745 inline_constructor => 0,
746 constructor_name => "_new",
747 inline_accessors => 0,
748 459 ) for qw/
749 Class::MOP::Package
750 Class::MOP::Module
751 Class::MOP::Class
752  
753 Class::MOP::Attribute
754 Class::MOP::Method
755 Class::MOP::Instance
756  
757 Class::MOP::Object
758  
759 Class::MOP::Method::Generated
760 Class::MOP::Method::Inlined
761  
762 Class::MOP::Method::Accessor
763 Class::MOP::Method::Constructor
764 Class::MOP::Method::Wrapped
765  
766 Class::MOP::Method::Meta
767  
768 Class::MOP::Overload
769 /;
770  
771 $_->meta->make_immutable(
772 inline_constructor => 0,
773 constructor_name => undef,
774 inline_accessors => 0,
775 459 ) for qw/
776 Class::MOP::Mixin
777 Class::MOP::Mixin::AttributeCore
778 Class::MOP::Mixin::HasAttributes
779 Class::MOP::Mixin::HasMethods
780 Class::MOP::Mixin::HasOverloads
781 /;
782  
783 459 1;
784  
785 # ABSTRACT: A Meta Object Protocol for Perl 5
786  
787 __END__
« blib/lib/Moose/Meta/Method/Accessor/Native/String/substr.pm ↑ Summary blib/lib/Moose/Meta/Method/Accessor/Native/Number/abs.pm »