File | /usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Moose/Meta/Attribute.pm |
Statements Executed | 380 |
Statement Execution Time | 5.30ms |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
1 | 1 | 1 | 5.56ms | 41.3ms | BEGIN@18 | Moose::Meta::Attribute::
1 | 1 | 1 | 1.55ms | 1.66ms | BEGIN@15 | Moose::Meta::Attribute::
1 | 1 | 1 | 1.50ms | 1.71ms | BEGIN@16 | Moose::Meta::Attribute::
1 | 1 | 1 | 1.14ms | 1.71ms | BEGIN@17 | Moose::Meta::Attribute::
5 | 2 | 2 | 636µs | 2.13ms | new | Moose::Meta::Attribute::
6 | 1 | 1 | 96µs | 4.80ms | _process_accessors | Moose::Meta::Attribute::
6 | 2 | 1 | 73µs | 5.53ms | install_accessors | Moose::Meta::Attribute::
4 | 1 | 1 | 56µs | 1.28ms | interpolate_class_and_new | Moose::Meta::Attribute::
5 | 1 | 1 | 40µs | 40µs | _process_options | Moose::Meta::Attribute::
4 | 1 | 1 | 21µs | 21µs | interpolate_class | Moose::Meta::Attribute::
4 | 1 | 1 | 20µs | 26µs | _check_associated_methods | Moose::Meta::Attribute::
1 | 1 | 1 | 15µs | 18µs | BEGIN@4 | Moose::Meta::Attribute::
1 | 1 | 1 | 9µs | 4.98ms | BEGIN@20 | Moose::Meta::Attribute::
5 | 1 | 2 | 9µs | 9µs | CORE:sort (opcode) | Moose::Meta::Attribute::
6 | 1 | 1 | 8µs | 8µs | accessor_metaclass | Moose::Meta::Attribute::
1 | 1 | 1 | 7µs | 37µs | BEGIN@9 | Moose::Meta::Attribute::
1 | 1 | 1 | 7µs | 31µs | BEGIN@8 | Moose::Meta::Attribute::
1 | 1 | 1 | 7µs | 36µs | BEGIN@7 | Moose::Meta::Attribute::
1 | 1 | 1 | 7µs | 16µs | BEGIN@5 | Moose::Meta::Attribute::
1 | 1 | 1 | 4µs | 4µs | BEGIN@10 | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | register_implementation | Moose::Meta::Attribute::Custom::Moose::
0 | 0 | 0 | 0s | 0s | __ANON__[:293] | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | __ANON__[:35] | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | __ANON__[:450] | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | __ANON__[:631] | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _call_builder | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _canonicalize_handles | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _coerce_and_verify | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _find_delegate_metaclass | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _get_delegate_method_list | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _make_delegation_method | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _set_initial_slot_value | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | _weaken_value | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | clone | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | clone_and_inherit_options | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | delegation_metaclass | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | does | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | get_value | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | initialize_instance_slot | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | install_delegation | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | legal_options_for_inheritance | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | remove_accessors | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | remove_delegation | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | set_value | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | throw_error | Moose::Meta::Attribute::
0 | 0 | 0 | 0s | 0s | verify_against_type_constraint | Moose::Meta::Attribute::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | |||||
2 | package Moose::Meta::Attribute; | ||||
3 | |||||
4 | 3 | 21µs | 2 | 20µs | # spent 18µs (15+3) within Moose::Meta::Attribute::BEGIN@4 which was called
# once (15µs+3µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 4 # spent 18µs making 1 call to Moose::Meta::Attribute::BEGIN@4
# spent 3µs making 1 call to strict::import |
5 | 3 | 23µs | 2 | 24µs | # spent 16µs (7+9) within Moose::Meta::Attribute::BEGIN@5 which was called
# once (7µs+9µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 5 # spent 16µs making 1 call to Moose::Meta::Attribute::BEGIN@5
# spent 8µs making 1 call to warnings::import |
6 | |||||
7 | 3 | 23µs | 2 | 64µs | # spent 36µs (7+28) within Moose::Meta::Attribute::BEGIN@7 which was called
# once (7µs+28µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 7 # spent 36µs making 1 call to Moose::Meta::Attribute::BEGIN@7
# spent 28µs making 1 call to Exporter::import |
8 | 3 | 22µs | 2 | 55µs | # spent 31µs (7+24) within Moose::Meta::Attribute::BEGIN@8 which was called
# once (7µs+24µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 8 # spent 31µs making 1 call to Moose::Meta::Attribute::BEGIN@8
# spent 24µs making 1 call to Exporter::import |
9 | 3 | 20µs | 2 | 66µs | # spent 37µs (7+30) within Moose::Meta::Attribute::BEGIN@9 which was called
# once (7µs+30µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 9 # spent 37µs making 1 call to Moose::Meta::Attribute::BEGIN@9
# spent 30µs making 1 call to Exporter::import |
10 | 3 | 48µs | 1 | 4µs | # spent 4µs within Moose::Meta::Attribute::BEGIN@10 which was called
# once (4µs+0s) by Moose::Meta::TypeCoercion::BEGIN@8 at line 10 # spent 4µs making 1 call to Moose::Meta::Attribute::BEGIN@10 |
11 | |||||
12 | 1 | 800ns | our $VERSION = '0.98'; | ||
13 | 1 | 400ns | our $AUTHORITY = 'cpan:STEVAN'; | ||
14 | |||||
15 | 3 | 116µs | 1 | 1.66ms | # spent 1.66ms (1.55+112µs) within Moose::Meta::Attribute::BEGIN@15 which was called
# once (1.55ms+112µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 15 # spent 1.66ms making 1 call to Moose::Meta::Attribute::BEGIN@15 |
16 | 3 | 756µs | 1 | 1.71ms | # spent 1.71ms (1.50+215µs) within Moose::Meta::Attribute::BEGIN@16 which was called
# once (1.50ms+215µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 16 # spent 1.71ms making 1 call to Moose::Meta::Attribute::BEGIN@16 |
17 | 3 | 91µs | 1 | 1.71ms | # spent 1.71ms (1.14+566µs) within Moose::Meta::Attribute::BEGIN@17 which was called
# once (1.14ms+566µs) by Moose::Meta::TypeCoercion::BEGIN@8 at line 17 # spent 1.71ms making 1 call to Moose::Meta::Attribute::BEGIN@17 |
18 | 3 | 681µs | 1 | 41.3ms | # spent 41.3ms (5.56+35.8) within Moose::Meta::Attribute::BEGIN@18 which was called
# once (5.56ms+35.8ms) by Moose::Meta::TypeCoercion::BEGIN@8 at line 18 # spent 41.3ms making 1 call to Moose::Meta::Attribute::BEGIN@18 |
19 | |||||
20 | 3 | 2.73ms | 2 | 9.95ms | # spent 4.98ms (9µs+4.97) within Moose::Meta::Attribute::BEGIN@20 which was called
# once (9µs+4.97ms) by Moose::Meta::TypeCoercion::BEGIN@8 at line 20 # spent 4.98ms making 1 call to Moose::Meta::Attribute::BEGIN@20
# spent 4.97ms making 1 call to base::import |
21 | |||||
22 | 1 | 8µs | 2 | 528µs | __PACKAGE__->meta->add_attribute('traits' => ( # spent 471µs making 1 call to Class::MOP::Mixin::HasAttributes::add_attribute
# spent 58µs making 1 call to Class::MOP::Object::meta |
23 | reader => 'applied_traits', | ||||
24 | predicate => 'has_applied_traits', | ||||
25 | )); | ||||
26 | |||||
27 | # we need to have a ->does method in here to | ||||
28 | # more easily support traits, and the introspection | ||||
29 | # of those traits. We extend the does check to look | ||||
30 | # for metatrait aliases. | ||||
31 | sub does { | ||||
32 | my ($self, $role_name) = @_; | ||||
33 | my $name = try { | ||||
34 | Moose::Util::resolve_metatrait_alias(Attribute => $role_name) | ||||
35 | }; | ||||
36 | return 0 if !defined($name); # failed to load class | ||||
37 | return $self->Moose::Object::does($name); | ||||
38 | } | ||||
39 | |||||
40 | sub throw_error { | ||||
41 | my $self = shift; | ||||
42 | my $class = ( ref $self && $self->associated_class ) || "Moose::Meta::Class"; | ||||
43 | unshift @_, "message" if @_ % 2 == 1; | ||||
44 | unshift @_, attr => $self if ref $self; | ||||
45 | unshift @_, $class; | ||||
46 | my $handler = $class->can("throw_error"); # to avoid incrementing depth by 1 | ||||
47 | goto $handler; | ||||
48 | } | ||||
49 | |||||
50 | # spent 2.13ms (636µs+1.49) within Moose::Meta::Attribute::new which was called 5 times, avg 426µs/call:
# 4 times (514µs+689µs) by Moose::Meta::Attribute::interpolate_class_and_new at line 78, avg 301µs/call
# once (122µs+805µs) by Moose::BEGIN@20 at line 20 of Moose/Meta/TypeCoercion.pm | ||||
51 | 175 | 459µs | my ($class, $name, %options) = @_; | ||
52 | $class->_process_options($name, \%options) unless $options{__hack_no_process_options}; # used from clone()... YECHKKK FIXME ICKY YUCK GROSS # spent 40µs making 5 calls to Moose::Meta::Attribute::_process_options, avg 8µs/call | ||||
53 | |||||
54 | delete $options{__hack_no_process_options}; | ||||
55 | |||||
56 | my %attrs = | ||||
57 | ( map { $_ => 1 } | ||||
58 | grep { defined } # spent 174µs making 140 calls to Class::MOP::Mixin::AttributeCore::init_arg, avg 1µs/call | ||||
59 | map { $_->init_arg() } # spent 239µs making 4 calls to Class::MOP::Class::Immutable::Class::MOP::Class::get_all_attributes, avg 60µs/call
# spent 92µs making 1 call to Class::MOP::Class::get_all_attributes
# spent 78µs making 5 calls to Class::MOP::Object::meta, avg 16µs/call | ||||
60 | $class->meta()->get_all_attributes() | ||||
61 | ); | ||||
62 | |||||
63 | my @bad = sort grep { ! $attrs{$_} } keys %options; # spent 9µs making 5 calls to Moose::Meta::Attribute::CORE:sort, avg 2µs/call | ||||
64 | |||||
65 | if (@bad) | ||||
66 | { | ||||
67 | Carp::cluck "Found unknown argument(s) passed to '$name' attribute constructor in '$class': @bad"; | ||||
68 | } | ||||
69 | |||||
70 | return $class->SUPER::new($name, %options); # spent 863µs making 5 calls to Class::MOP::Attribute::new, avg 173µs/call | ||||
71 | } | ||||
72 | |||||
73 | # spent 1.28ms (56µs+1.22) within Moose::Meta::Attribute::interpolate_class_and_new which was called 4 times, avg 320µs/call:
# 4 times (56µs+1.22ms) by Moose::Meta::Class::_process_new_attribute at line 607 of Moose/Meta/Class.pm, avg 320µs/call | ||||
74 | 12 | 41µs | my ($class, $name, %args) = @_; | ||
75 | |||||
76 | my ( $new_class, @traits ) = $class->interpolate_class(\%args); # spent 21µs making 4 calls to Moose::Meta::Attribute::interpolate_class, avg 5µs/call | ||||
77 | |||||
78 | $new_class->new($name, %args, ( scalar(@traits) ? ( traits => \@traits ) : () ) ); # spent 1.20ms making 4 calls to Moose::Meta::Attribute::new, avg 301µs/call | ||||
79 | } | ||||
80 | |||||
81 | # spent 21µs within Moose::Meta::Attribute::interpolate_class which was called 4 times, avg 5µs/call:
# 4 times (21µs+0s) by Moose::Meta::Attribute::interpolate_class_and_new at line 76, avg 5µs/call | ||||
82 | 24 | 29µs | my ($class, $options) = @_; | ||
83 | |||||
84 | $class = ref($class) || $class; | ||||
85 | |||||
86 | if ( my $metaclass_name = delete $options->{metaclass} ) { | ||||
87 | my $new_class = Moose::Util::resolve_metaclass_alias( Attribute => $metaclass_name ); | ||||
88 | |||||
89 | if ( $class ne $new_class ) { | ||||
90 | if ( $new_class->can("interpolate_class") ) { | ||||
91 | return $new_class->interpolate_class($options); | ||||
92 | } else { | ||||
93 | $class = $new_class; | ||||
94 | } | ||||
95 | } | ||||
96 | } | ||||
97 | |||||
98 | my @traits; | ||||
99 | |||||
100 | if (my $traits = $options->{traits}) { | ||||
101 | my $i = 0; | ||||
102 | while ($i < @$traits) { | ||||
103 | my $trait = $traits->[$i++]; | ||||
104 | next if ref($trait); # options to a trait we discarded | ||||
105 | |||||
106 | $trait = Moose::Util::resolve_metatrait_alias(Attribute => $trait) | ||||
107 | || $trait; | ||||
108 | |||||
109 | next if $class->does($trait); | ||||
110 | |||||
111 | push @traits, $trait; | ||||
112 | |||||
113 | # are there options? | ||||
114 | push @traits, $traits->[$i++] | ||||
115 | if $traits->[$i] && ref($traits->[$i]); | ||||
116 | } | ||||
117 | |||||
118 | if (@traits) { | ||||
119 | my $anon_class = Moose::Meta::Class->create_anon_class( | ||||
120 | superclasses => [ $class ], | ||||
121 | roles => [ @traits ], | ||||
122 | cache => 1, | ||||
123 | ); | ||||
124 | |||||
125 | $class = $anon_class->name; | ||||
126 | } | ||||
127 | } | ||||
128 | |||||
129 | return ( wantarray ? ( $class, @traits ) : $class ); | ||||
130 | } | ||||
131 | |||||
132 | # ... | ||||
133 | |||||
134 | 1 | 2µs | my @legal_options_for_inheritance = qw( | ||
135 | default coerce required | ||||
136 | documentation lazy handles | ||||
137 | builder type_constraint | ||||
138 | definition_context | ||||
139 | lazy_build weak_ref | ||||
140 | ); | ||||
141 | |||||
142 | sub legal_options_for_inheritance { @legal_options_for_inheritance } | ||||
143 | |||||
144 | # NOTE/TODO | ||||
145 | # This method *must* be able to handle | ||||
146 | # Class::MOP::Attribute instances as | ||||
147 | # well. Yes, I know that is wrong, but | ||||
148 | # apparently we didn't realize it was | ||||
149 | # doing that and now we have some code | ||||
150 | # which is dependent on it. The real | ||||
151 | # solution of course is to push this | ||||
152 | # feature back up into Class::MOP::Attribute | ||||
153 | # but I not right now, I am too lazy. | ||||
154 | # However if you are reading this and | ||||
155 | # looking for something to do,.. please | ||||
156 | # be my guest. | ||||
157 | # - stevan | ||||
158 | sub clone_and_inherit_options { | ||||
159 | my ($self, %options) = @_; | ||||
160 | |||||
161 | my %copy = %options; | ||||
162 | |||||
163 | my %actual_options; | ||||
164 | |||||
165 | # NOTE: | ||||
166 | # we may want to extends a Class::MOP::Attribute | ||||
167 | # in which case we need to be able to use the | ||||
168 | # core set of legal options that have always | ||||
169 | # been here. But we allows Moose::Meta::Attribute | ||||
170 | # instances to changes them. | ||||
171 | # - SL | ||||
172 | my @legal_options = $self->can('legal_options_for_inheritance') | ||||
173 | ? $self->legal_options_for_inheritance | ||||
174 | : @legal_options_for_inheritance; | ||||
175 | |||||
176 | foreach my $legal_option (@legal_options) { | ||||
177 | if (exists $options{$legal_option}) { | ||||
178 | $actual_options{$legal_option} = $options{$legal_option}; | ||||
179 | delete $options{$legal_option}; | ||||
180 | } | ||||
181 | } | ||||
182 | |||||
183 | if ($options{isa}) { | ||||
184 | my $type_constraint; | ||||
185 | if (blessed($options{isa}) && $options{isa}->isa('Moose::Meta::TypeConstraint')) { | ||||
186 | $type_constraint = $options{isa}; | ||||
187 | } | ||||
188 | else { | ||||
189 | $type_constraint = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options{isa}); | ||||
190 | (defined $type_constraint) | ||||
191 | || $self->throw_error("Could not find the type constraint '" . $options{isa} . "'", data => $options{isa}); | ||||
192 | } | ||||
193 | |||||
194 | $actual_options{type_constraint} = $type_constraint; | ||||
195 | delete $options{isa}; | ||||
196 | } | ||||
197 | |||||
198 | if ($options{does}) { | ||||
199 | my $type_constraint; | ||||
200 | if (blessed($options{does}) && $options{does}->isa('Moose::Meta::TypeConstraint')) { | ||||
201 | $type_constraint = $options{does}; | ||||
202 | } | ||||
203 | else { | ||||
204 | $type_constraint = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options{does}); | ||||
205 | (defined $type_constraint) | ||||
206 | || $self->throw_error("Could not find the type constraint '" . $options{does} . "'", data => $options{does}); | ||||
207 | } | ||||
208 | |||||
209 | $actual_options{type_constraint} = $type_constraint; | ||||
210 | delete $options{does}; | ||||
211 | } | ||||
212 | |||||
213 | # NOTE: | ||||
214 | # this doesn't apply to Class::MOP::Attributes, | ||||
215 | # so we can ignore it for them. | ||||
216 | # - SL | ||||
217 | if ($self->can('interpolate_class')) { | ||||
218 | ( $actual_options{metaclass}, my @traits ) = $self->interpolate_class(\%options); | ||||
219 | |||||
220 | my %seen; | ||||
221 | my @all_traits = grep { $seen{$_}++ } @{ $self->applied_traits || [] }, @traits; | ||||
222 | $actual_options{traits} = \@all_traits if @all_traits; | ||||
223 | |||||
224 | delete @options{qw(metaclass traits)}; | ||||
225 | } | ||||
226 | |||||
227 | (scalar keys %options == 0) | ||||
228 | || $self->throw_error("Illegal inherited options => (" . (join ', ' => keys %options) . ")", data => \%options); | ||||
229 | |||||
230 | |||||
231 | $self->clone(%actual_options); | ||||
232 | } | ||||
233 | |||||
234 | sub clone { | ||||
235 | my ( $self, %params ) = @_; | ||||
236 | |||||
237 | my $class = delete $params{metaclass} || ref $self; | ||||
238 | |||||
239 | my ( @init, @non_init ); | ||||
240 | |||||
241 | foreach my $attr ( grep { $_->has_value($self) } Class::MOP::class_of($self)->get_all_attributes ) { | ||||
242 | push @{ $attr->has_init_arg ? \@init : \@non_init }, $attr; | ||||
243 | } | ||||
244 | |||||
245 | my %new_params = ( ( map { $_->init_arg => $_->get_value($self) } @init ), %params ); | ||||
246 | |||||
247 | my $name = delete $new_params{name}; | ||||
248 | |||||
249 | my $clone = $class->new($name, %new_params, __hack_no_process_options => 1 ); | ||||
250 | |||||
251 | foreach my $attr ( @non_init ) { | ||||
252 | $attr->set_value($clone, $attr->get_value($self)); | ||||
253 | } | ||||
254 | |||||
255 | return $clone; | ||||
256 | } | ||||
257 | |||||
258 | # spent 40µs within Moose::Meta::Attribute::_process_options which was called 5 times, avg 8µs/call:
# 5 times (40µs+0s) by Moose::Meta::Attribute::new at line 52, avg 8µs/call | ||||
259 | 57 | 42µs | my ($class, $name, $options) = @_; | ||
260 | |||||
261 | if (exists $options->{is}) { | ||||
262 | |||||
263 | ### ------------------------- | ||||
264 | ## is => ro, writer => _foo # turns into (reader => foo, writer => _foo) as before | ||||
265 | ## is => rw, writer => _foo # turns into (reader => foo, writer => _foo) | ||||
266 | ## is => rw, accessor => _foo # turns into (accessor => _foo) | ||||
267 | ## is => ro, accessor => _foo # error, accesor is rw | ||||
268 | ### ------------------------- | ||||
269 | |||||
270 | if ($options->{is} eq 'ro') { | ||||
271 | $class->throw_error("Cannot define an accessor name on a read-only attribute, accessors are read/write", data => $options) | ||||
272 | if exists $options->{accessor}; | ||||
273 | $options->{reader} ||= $name; | ||||
274 | } | ||||
275 | elsif ($options->{is} eq 'rw') { | ||||
276 | if ($options->{writer}) { | ||||
277 | $options->{reader} ||= $name; | ||||
278 | } | ||||
279 | else { | ||||
280 | $options->{accessor} ||= $name; | ||||
281 | } | ||||
282 | } | ||||
283 | elsif ($options->{is} eq 'bare') { | ||||
284 | # do nothing, but don't complain (later) about missing methods | ||||
285 | } | ||||
286 | else { | ||||
287 | $class->throw_error("I do not understand this option (is => " . $options->{is} . ") on attribute ($name)", data => $options->{is}); | ||||
288 | } | ||||
289 | } | ||||
290 | |||||
291 | if (exists $options->{isa}) { | ||||
292 | if (exists $options->{does}) { | ||||
293 | if (try { $options->{isa}->can('does') }) { | ||||
294 | ($options->{isa}->does($options->{does})) | ||||
295 | || $class->throw_error("Cannot have an isa option and a does option if the isa does not do the does on attribute ($name)", data => $options); | ||||
296 | } | ||||
297 | else { | ||||
298 | $class->throw_error("Cannot have an isa option which cannot ->does() on attribute ($name)", data => $options); | ||||
299 | } | ||||
300 | } | ||||
301 | |||||
302 | # allow for anon-subtypes here ... | ||||
303 | if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) { | ||||
304 | $options->{type_constraint} = $options->{isa}; | ||||
305 | } | ||||
306 | else { | ||||
307 | $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options->{isa}); | ||||
308 | } | ||||
309 | } | ||||
310 | elsif (exists $options->{does}) { | ||||
311 | # allow for anon-subtypes here ... | ||||
312 | if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) { | ||||
313 | $options->{type_constraint} = $options->{does}; | ||||
314 | } | ||||
315 | else { | ||||
316 | $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options->{does}); | ||||
317 | } | ||||
318 | } | ||||
319 | |||||
320 | if (exists $options->{coerce} && $options->{coerce}) { | ||||
321 | (exists $options->{type_constraint}) | ||||
322 | || $class->throw_error("You cannot have coercion without specifying a type constraint on attribute ($name)", data => $options); | ||||
323 | $class->throw_error("You cannot have a weak reference to a coerced value on attribute ($name)", data => $options) | ||||
324 | if $options->{weak_ref}; | ||||
325 | } | ||||
326 | |||||
327 | if (exists $options->{trigger}) { | ||||
328 | ('CODE' eq ref $options->{trigger}) | ||||
329 | || $class->throw_error("Trigger must be a CODE ref on attribute ($name)", data => $options->{trigger}); | ||||
330 | } | ||||
331 | |||||
332 | if (exists $options->{auto_deref} && $options->{auto_deref}) { | ||||
333 | (exists $options->{type_constraint}) | ||||
334 | || $class->throw_error("You cannot auto-dereference without specifying a type constraint on attribute ($name)", data => $options); | ||||
335 | ($options->{type_constraint}->is_a_type_of('ArrayRef') || | ||||
336 | $options->{type_constraint}->is_a_type_of('HashRef')) | ||||
337 | || $class->throw_error("You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute ($name)", data => $options); | ||||
338 | } | ||||
339 | |||||
340 | if (exists $options->{lazy_build} && $options->{lazy_build} == 1) { | ||||
341 | $class->throw_error("You can not use lazy_build and default for the same attribute ($name)", data => $options) | ||||
342 | if exists $options->{default}; | ||||
343 | $options->{lazy} = 1; | ||||
344 | $options->{builder} ||= "_build_${name}"; | ||||
345 | if ($name =~ /^_/) { | ||||
346 | $options->{clearer} ||= "_clear${name}"; | ||||
347 | $options->{predicate} ||= "_has${name}"; | ||||
348 | } | ||||
349 | else { | ||||
350 | $options->{clearer} ||= "clear_${name}"; | ||||
351 | $options->{predicate} ||= "has_${name}"; | ||||
352 | } | ||||
353 | } | ||||
354 | |||||
355 | if (exists $options->{lazy} && $options->{lazy}) { | ||||
356 | (exists $options->{default} || defined $options->{builder} ) | ||||
357 | || $class->throw_error("You cannot have lazy attribute ($name) without specifying a default value for it", data => $options); | ||||
358 | } | ||||
359 | |||||
360 | if ( $options->{required} && !( ( !exists $options->{init_arg} || defined $options->{init_arg} ) || exists $options->{default} || defined $options->{builder} ) ) { | ||||
361 | $class->throw_error("You cannot have a required attribute ($name) without a default, builder, or an init_arg", data => $options); | ||||
362 | } | ||||
363 | |||||
364 | } | ||||
365 | |||||
366 | sub initialize_instance_slot { | ||||
367 | my ($self, $meta_instance, $instance, $params) = @_; | ||||
368 | my $init_arg = $self->init_arg(); | ||||
369 | # try to fetch the init arg from the %params ... | ||||
370 | |||||
371 | my $val; | ||||
372 | my $value_is_set; | ||||
373 | if ( defined($init_arg) and exists $params->{$init_arg}) { | ||||
374 | $val = $params->{$init_arg}; | ||||
375 | $value_is_set = 1; | ||||
376 | } | ||||
377 | else { | ||||
378 | # skip it if it's lazy | ||||
379 | return if $self->is_lazy; | ||||
380 | # and die if it's required and doesn't have a default value | ||||
381 | $self->throw_error("Attribute (" . $self->name . ") is required", object => $instance, data => $params) | ||||
382 | if $self->is_required && !$self->has_default && !$self->has_builder; | ||||
383 | |||||
384 | # if nothing was in the %params, we can use the | ||||
385 | # attribute's default value (if it has one) | ||||
386 | if ($self->has_default) { | ||||
387 | $val = $self->default($instance); | ||||
388 | $value_is_set = 1; | ||||
389 | } | ||||
390 | elsif ($self->has_builder) { | ||||
391 | $val = $self->_call_builder($instance); | ||||
392 | $value_is_set = 1; | ||||
393 | } | ||||
394 | } | ||||
395 | |||||
396 | return unless $value_is_set; | ||||
397 | |||||
398 | $val = $self->_coerce_and_verify( $val, $instance ); | ||||
399 | |||||
400 | $self->set_initial_value($instance, $val); | ||||
401 | |||||
402 | if ( ref $val && $self->is_weak_ref ) { | ||||
403 | $self->_weaken_value($instance); | ||||
404 | } | ||||
405 | } | ||||
406 | |||||
407 | sub _call_builder { | ||||
408 | my ( $self, $instance ) = @_; | ||||
409 | |||||
410 | my $builder = $self->builder(); | ||||
411 | |||||
412 | return $instance->$builder() | ||||
413 | if $instance->can( $self->builder ); | ||||
414 | |||||
415 | $self->throw_error( blessed($instance) | ||||
416 | . " does not support builder method '" | ||||
417 | . $self->builder | ||||
418 | . "' for attribute '" | ||||
419 | . $self->name | ||||
420 | . "'", | ||||
421 | object => $instance, | ||||
422 | ); | ||||
423 | } | ||||
424 | |||||
425 | ## Slot management | ||||
426 | |||||
427 | # FIXME: | ||||
428 | # this duplicates too much code from | ||||
429 | # Class::MOP::Attribute, we need to | ||||
430 | # refactor these bits eventually. | ||||
431 | # - SL | ||||
432 | sub _set_initial_slot_value { | ||||
433 | my ($self, $meta_instance, $instance, $value) = @_; | ||||
434 | |||||
435 | my $slot_name = $self->name; | ||||
436 | |||||
437 | return $meta_instance->set_slot_value($instance, $slot_name, $value) | ||||
438 | unless $self->has_initializer; | ||||
439 | |||||
440 | my ($type_constraint, $can_coerce); | ||||
441 | if ($self->has_type_constraint) { | ||||
442 | $type_constraint = $self->type_constraint; | ||||
443 | $can_coerce = ($self->should_coerce && $type_constraint->has_coercion); | ||||
444 | } | ||||
445 | |||||
446 | my $callback = sub { | ||||
447 | my $val = $self->_coerce_and_verify( shift, $instance );; | ||||
448 | |||||
449 | $meta_instance->set_slot_value($instance, $slot_name, $val); | ||||
450 | }; | ||||
451 | |||||
452 | my $initializer = $self->initializer; | ||||
453 | |||||
454 | # most things will just want to set a value, so make it first arg | ||||
455 | $instance->$initializer($value, $callback, $self); | ||||
456 | } | ||||
457 | |||||
458 | sub set_value { | ||||
459 | my ($self, $instance, @args) = @_; | ||||
460 | my $value = $args[0]; | ||||
461 | |||||
462 | my $attr_name = $self->name; | ||||
463 | |||||
464 | if ($self->is_required and not @args) { | ||||
465 | $self->throw_error("Attribute ($attr_name) is required", object => $instance); | ||||
466 | } | ||||
467 | |||||
468 | $value = $self->_coerce_and_verify( $value, $instance ); | ||||
469 | |||||
470 | my @old; | ||||
471 | if ( $self->has_trigger && $self->has_value($instance) ) { | ||||
472 | @old = $self->get_value($instance, 'for trigger'); | ||||
473 | } | ||||
474 | |||||
475 | $self->SUPER::set_value($instance, $value); | ||||
476 | |||||
477 | if ( ref $value && $self->is_weak_ref ) { | ||||
478 | $self->_weaken_value($instance); | ||||
479 | } | ||||
480 | |||||
481 | if ($self->has_trigger) { | ||||
482 | $self->trigger->($instance, $value, @old); | ||||
483 | } | ||||
484 | } | ||||
485 | |||||
486 | sub _weaken_value { | ||||
487 | my ( $self, $instance ) = @_; | ||||
488 | |||||
489 | my $meta_instance = Class::MOP::Class->initialize( blessed($instance) ) | ||||
490 | ->get_meta_instance; | ||||
491 | |||||
492 | $meta_instance->weaken_slot_value( $instance, $self->name ); | ||||
493 | } | ||||
494 | |||||
495 | sub get_value { | ||||
496 | my ($self, $instance, $for_trigger) = @_; | ||||
497 | |||||
498 | if ($self->is_lazy) { | ||||
499 | unless ($self->has_value($instance)) { | ||||
500 | my $value; | ||||
501 | if ($self->has_default) { | ||||
502 | $value = $self->default($instance); | ||||
503 | } elsif ( $self->has_builder ) { | ||||
504 | $value = $self->_call_builder($instance); | ||||
505 | } | ||||
506 | |||||
507 | $value = $self->_coerce_and_verify( $value, $instance ); | ||||
508 | |||||
509 | $self->set_initial_value($instance, $value); | ||||
510 | } | ||||
511 | } | ||||
512 | |||||
513 | if ( $self->should_auto_deref && ! $for_trigger ) { | ||||
514 | |||||
515 | my $type_constraint = $self->type_constraint; | ||||
516 | |||||
517 | if ($type_constraint->is_a_type_of('ArrayRef')) { | ||||
518 | my $rv = $self->SUPER::get_value($instance); | ||||
519 | return unless defined $rv; | ||||
520 | return wantarray ? @{ $rv } : $rv; | ||||
521 | } | ||||
522 | elsif ($type_constraint->is_a_type_of('HashRef')) { | ||||
523 | my $rv = $self->SUPER::get_value($instance); | ||||
524 | return unless defined $rv; | ||||
525 | return wantarray ? %{ $rv } : $rv; | ||||
526 | } | ||||
527 | else { | ||||
528 | $self->throw_error("Can not auto de-reference the type constraint '" . $type_constraint->name . "'", object => $instance, type_constraint => $type_constraint); | ||||
529 | } | ||||
530 | |||||
531 | } | ||||
532 | else { | ||||
533 | |||||
534 | return $self->SUPER::get_value($instance); | ||||
535 | } | ||||
536 | } | ||||
537 | |||||
538 | ## installing accessors | ||||
539 | |||||
540 | 6 | 17µs | # spent 8µs within Moose::Meta::Attribute::accessor_metaclass which was called 6 times, avg 1µs/call:
# 6 times (8µ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 1µs/call | ||
541 | |||||
542 | # spent 5.53ms (73µs+5.46) within Moose::Meta::Attribute::install_accessors which was called 6 times, avg 922µs/call:
# 5 times (60µs+4.38ms) by Class::MOP::Class::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP/Class.pm:515] at line 514 of Class/MOP/Class.pm, avg 888µs/call
# once (13µs+1.08ms) by Class::MOP::Class::_inline_accessors at line 1030 of Class/MOP/Class.pm | ||||
543 | 24 | 64µs | my $self = shift; | ||
544 | $self->SUPER::install_accessors(@_); # spent 5.38ms making 6 calls to Class::MOP::Attribute::install_accessors, avg 897µs/call | ||||
545 | $self->install_delegation if $self->has_handles; # spent 73µs making 6 calls to Moose::Meta::Mixin::AttributeCore::has_handles, avg 12µs/call | ||||
546 | return; | ||||
547 | } | ||||
548 | |||||
549 | # spent 26µs (20+5) within Moose::Meta::Attribute::_check_associated_methods which was called 4 times, avg 6µs/call:
# 4 times (20µs+5µs) by Moose::Meta::Class::add_attribute at line 303 of Moose/Meta/Class.pm, avg 6µs/call | ||||
550 | 8 | 17µs | my $self = shift; | ||
551 | unless ( # spent 5µs making 4 calls to Class::MOP::Attribute::associated_methods, avg 1µs/call | ||||
552 | @{ $self->associated_methods } | ||||
553 | || ($self->_is_metadata || '') eq 'bare' | ||||
554 | ) { | ||||
555 | Carp::cluck( | ||||
556 | 'Attribute (' . $self->name . ') of class ' | ||||
557 | . $self->associated_class->name | ||||
558 | . ' has no associated methods' | ||||
559 | . ' (did you mean to provide an "is" argument?)' | ||||
560 | . "\n" | ||||
561 | ) | ||||
562 | } | ||||
563 | } | ||||
564 | |||||
565 | # spent 4.80ms (96µs+4.71) within Moose::Meta::Attribute::_process_accessors which was called 6 times, avg 801µs/call:
# 6 times (96µs+4.71ms) by Class::MOP::Attribute::install_accessors at line 358 of Class/MOP/Attribute.pm, avg 801µs/call | ||||
566 | 36 | 74µs | my $self = shift; | ||
567 | my ($type, $accessor, $generate_as_inline_methods) = @_; | ||||
568 | $accessor = (keys %$accessor)[0] if (ref($accessor)||'') eq 'HASH'; | ||||
569 | my $method = $self->associated_class->get_method($accessor); # spent 237µs making 6 calls to Class::MOP::Mixin::HasMethods::get_method, avg 39µs/call
# spent 5µs making 6 calls to Class::MOP::Attribute::associated_class, avg 900ns/call | ||||
570 | if ($method && !$method->isa('Class::MOP::Method::Accessor') # spent 1µs making 1 call to UNIVERSAL::isa | ||||
571 | && (!$self->definition_context | ||||
572 | || $method->package_name eq $self->definition_context->{package})) { | ||||
573 | Carp::cluck( | ||||
574 | "You are overwriting a locally defined method ($accessor) with " | ||||
575 | . "an accessor" | ||||
576 | ); | ||||
577 | } | ||||
578 | $self->SUPER::_process_accessors(@_); # spent 4.46ms making 6 calls to Class::MOP::Attribute::_process_accessors, avg 744µs/call | ||||
579 | } | ||||
580 | |||||
581 | sub remove_accessors { | ||||
582 | my $self = shift; | ||||
583 | $self->SUPER::remove_accessors(@_); | ||||
584 | $self->remove_delegation if $self->has_handles; | ||||
585 | return; | ||||
586 | } | ||||
587 | |||||
588 | sub install_delegation { | ||||
589 | my $self = shift; | ||||
590 | |||||
591 | # NOTE: | ||||
592 | # Here we canonicalize the 'handles' option | ||||
593 | # this will sort out any details and always | ||||
594 | # return an hash of methods which we want | ||||
595 | # to delagate to, see that method for details | ||||
596 | my %handles = $self->_canonicalize_handles; | ||||
597 | |||||
598 | |||||
599 | # install the delegation ... | ||||
600 | my $associated_class = $self->associated_class; | ||||
601 | foreach my $handle (keys %handles) { | ||||
602 | my $method_to_call = $handles{$handle}; | ||||
603 | my $class_name = $associated_class->name; | ||||
604 | my $name = "${class_name}::${handle}"; | ||||
605 | |||||
606 | (!$associated_class->has_method($handle)) | ||||
607 | || $self->throw_error("You cannot overwrite a locally defined method ($handle) with a delegation", method_name => $handle); | ||||
608 | |||||
609 | # NOTE: | ||||
610 | # handles is not allowed to delegate | ||||
611 | # any of these methods, as they will | ||||
612 | # override the ones in your class, which | ||||
613 | # is almost certainly not what you want. | ||||
614 | |||||
615 | # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something | ||||
616 | #cluck("Not delegating method '$handle' because it is a core method") and | ||||
617 | next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle); | ||||
618 | |||||
619 | my $method = $self->_make_delegation_method($handle, $method_to_call); | ||||
620 | |||||
621 | $self->associated_class->add_method($method->name, $method); | ||||
622 | $self->associate_method($method); | ||||
623 | } | ||||
624 | } | ||||
625 | |||||
626 | sub remove_delegation { | ||||
627 | my $self = shift; | ||||
628 | my %handles = $self->_canonicalize_handles; | ||||
629 | my $associated_class = $self->associated_class; | ||||
630 | foreach my $handle (keys %handles) { | ||||
631 | next unless any { $handle eq $_ } | ||||
632 | map { $_->name } | ||||
633 | @{ $self->associated_methods }; | ||||
634 | $self->associated_class->remove_method($handle); | ||||
635 | } | ||||
636 | } | ||||
637 | |||||
638 | # private methods to help delegation ... | ||||
639 | |||||
640 | sub _canonicalize_handles { | ||||
641 | my $self = shift; | ||||
642 | my $handles = $self->handles; | ||||
643 | if (my $handle_type = ref($handles)) { | ||||
644 | if ($handle_type eq 'HASH') { | ||||
645 | return %{$handles}; | ||||
646 | } | ||||
647 | elsif ($handle_type eq 'ARRAY') { | ||||
648 | return map { $_ => $_ } @{$handles}; | ||||
649 | } | ||||
650 | elsif ($handle_type eq 'Regexp') { | ||||
651 | ($self->has_type_constraint) | ||||
652 | || $self->throw_error("Cannot delegate methods based on a Regexp without a type constraint (isa)", data => $handles); | ||||
653 | return map { ($_ => $_) } | ||||
654 | grep { /$handles/ } $self->_get_delegate_method_list; | ||||
655 | } | ||||
656 | elsif ($handle_type eq 'CODE') { | ||||
657 | return $handles->($self, $self->_find_delegate_metaclass); | ||||
658 | } | ||||
659 | elsif (blessed($handles) && $handles->isa('Moose::Meta::TypeConstraint::DuckType')) { | ||||
660 | return map { $_ => $_ } @{ $handles->methods }; | ||||
661 | } | ||||
662 | else { | ||||
663 | $self->throw_error("Unable to canonicalize the 'handles' option with $handles", data => $handles); | ||||
664 | } | ||||
665 | } | ||||
666 | else { | ||||
667 | Class::MOP::load_class($handles); | ||||
668 | my $role_meta = Class::MOP::class_of($handles); | ||||
669 | |||||
670 | (blessed $role_meta && $role_meta->isa('Moose::Meta::Role')) | ||||
671 | || $self->throw_error("Unable to canonicalize the 'handles' option with $handles because its metaclass is not a Moose::Meta::Role", data => $handles); | ||||
672 | |||||
673 | return map { $_ => $_ } | ||||
674 | grep { $_ ne 'meta' } ( | ||||
675 | $role_meta->get_method_list, | ||||
676 | map { $_->name } $role_meta->get_required_method_list, | ||||
677 | ); | ||||
678 | } | ||||
679 | } | ||||
680 | |||||
681 | sub _find_delegate_metaclass { | ||||
682 | my $self = shift; | ||||
683 | if (my $class = $self->_isa_metadata) { | ||||
684 | # we might be dealing with a non-Moose class, | ||||
685 | # and need to make our own metaclass. if there's | ||||
686 | # already a metaclass, it will be returned | ||||
687 | return Moose::Meta::Class->initialize($class); | ||||
688 | } | ||||
689 | elsif (my $role = $self->_does_metadata) { | ||||
690 | return Class::MOP::class_of($role); | ||||
691 | } | ||||
692 | else { | ||||
693 | $self->throw_error("Cannot find delegate metaclass for attribute " . $self->name); | ||||
694 | } | ||||
695 | } | ||||
696 | |||||
697 | sub _get_delegate_method_list { | ||||
698 | my $self = shift; | ||||
699 | my $meta = $self->_find_delegate_metaclass; | ||||
700 | if ($meta->isa('Class::MOP::Class')) { | ||||
701 | return map { $_->name } # NOTE: !never! delegate &meta | ||||
702 | grep { $_->package_name ne 'Moose::Object' && $_->name ne 'meta' } | ||||
703 | $meta->get_all_methods; | ||||
704 | } | ||||
705 | elsif ($meta->isa('Moose::Meta::Role')) { | ||||
706 | return $meta->get_method_list; | ||||
707 | } | ||||
708 | else { | ||||
709 | $self->throw_error("Unable to recognize the delegate metaclass '$meta'", data => $meta); | ||||
710 | } | ||||
711 | } | ||||
712 | |||||
713 | sub delegation_metaclass { 'Moose::Meta::Method::Delegation' } | ||||
714 | |||||
715 | sub _make_delegation_method { | ||||
716 | my ( $self, $handle_name, $method_to_call ) = @_; | ||||
717 | |||||
718 | my @curried_arguments; | ||||
719 | |||||
720 | ($method_to_call, @curried_arguments) = @$method_to_call | ||||
721 | if 'ARRAY' eq ref($method_to_call); | ||||
722 | |||||
723 | return $self->delegation_metaclass->new( | ||||
724 | name => $handle_name, | ||||
725 | package_name => $self->associated_class->name, | ||||
726 | attribute => $self, | ||||
727 | delegate_to_method => $method_to_call, | ||||
728 | curried_arguments => \@curried_arguments, | ||||
729 | ); | ||||
730 | } | ||||
731 | |||||
732 | sub _coerce_and_verify { | ||||
733 | my $self = shift; | ||||
734 | my $val = shift; | ||||
735 | my $instance = shift; | ||||
736 | |||||
737 | return $val unless $self->has_type_constraint; | ||||
738 | |||||
739 | my $type_constraint = $self->type_constraint; | ||||
740 | if ($self->should_coerce && $type_constraint->has_coercion) { | ||||
741 | $val = $type_constraint->coerce($val); | ||||
742 | } | ||||
743 | |||||
744 | $self->verify_against_type_constraint($val, instance => $instance); | ||||
745 | |||||
746 | return $val; | ||||
747 | } | ||||
748 | |||||
749 | sub verify_against_type_constraint { | ||||
750 | my $self = shift; | ||||
751 | my $val = shift; | ||||
752 | |||||
753 | return 1 if !$self->has_type_constraint; | ||||
754 | |||||
755 | my $type_constraint = $self->type_constraint; | ||||
756 | |||||
757 | $type_constraint->check($val) | ||||
758 | || $self->throw_error("Attribute (" | ||||
759 | . $self->name | ||||
760 | . ") does not pass the type constraint because: " | ||||
761 | . $type_constraint->get_message($val), data => $val, @_); | ||||
762 | } | ||||
763 | |||||
764 | package Moose::Meta::Attribute::Custom::Moose; | ||||
765 | sub register_implementation { 'Moose::Meta::Attribute' } | ||||
766 | |||||
767 | 1 | 10µs | 1; | ||
768 | |||||
769 | __END__ | ||||
770 | |||||
771 | =pod | ||||
772 | |||||
773 | =head1 NAME | ||||
774 | |||||
775 | Moose::Meta::Attribute - The Moose attribute metaclass | ||||
776 | |||||
777 | =head1 DESCRIPTION | ||||
778 | |||||
779 | This class is a subclass of L<Class::MOP::Attribute> that provides | ||||
780 | additional Moose-specific functionality. | ||||
781 | |||||
782 | To really understand this class, you will need to start with the | ||||
783 | L<Class::MOP::Attribute> documentation. This class can be understood | ||||
784 | as a set of additional features on top of the basic feature provided | ||||
785 | by that parent class. | ||||
786 | |||||
787 | =head1 INHERITANCE | ||||
788 | |||||
789 | C<Moose::Meta::Attribute> is a subclass of L<Class::MOP::Attribute>. | ||||
790 | |||||
791 | =head1 METHODS | ||||
792 | |||||
793 | Many of the documented below override methods in | ||||
794 | L<Class::MOP::Attribute> and add Moose specific features. | ||||
795 | |||||
796 | =head2 Creation | ||||
797 | |||||
798 | =over 4 | ||||
799 | |||||
800 | =item B<< Moose::Meta::Attribute->new(%options) >> | ||||
801 | |||||
802 | This method overrides the L<Class::MOP::Attribute> constructor. | ||||
803 | |||||
804 | Many of the options below are described in more detail in the | ||||
805 | L<Moose::Manual::Attributes> document. | ||||
806 | |||||
807 | It adds the following options to the constructor: | ||||
808 | |||||
809 | =over 8 | ||||
810 | |||||
811 | =item * is => 'ro', 'rw', 'bare' | ||||
812 | |||||
813 | This provides a shorthand for specifying the C<reader>, C<writer>, or | ||||
814 | C<accessor> names. If the attribute is read-only ('ro') then it will | ||||
815 | have a C<reader> method with the same attribute as the name. | ||||
816 | |||||
817 | If it is read-write ('rw') then it will have an C<accessor> method | ||||
818 | with the same name. If you provide an explicit C<writer> for a | ||||
819 | read-write attribute, then you will have a C<reader> with the same | ||||
820 | name as the attribute, and a C<writer> with the name you provided. | ||||
821 | |||||
822 | Use 'bare' when you are deliberately not installing any methods | ||||
823 | (accessor, reader, etc.) associated with this attribute; otherwise, | ||||
824 | Moose will issue a deprecation warning when this attribute is added to a | ||||
825 | metaclass. | ||||
826 | |||||
827 | =item * isa => $type | ||||
828 | |||||
829 | This option accepts a type. The type can be a string, which should be | ||||
830 | a type name. If the type name is unknown, it is assumed to be a class | ||||
831 | name. | ||||
832 | |||||
833 | This option can also accept a L<Moose::Meta::TypeConstraint> object. | ||||
834 | |||||
835 | If you I<also> provide a C<does> option, then your C<isa> option must | ||||
836 | be a class name, and that class must do the role specified with | ||||
837 | C<does>. | ||||
838 | |||||
839 | =item * does => $role | ||||
840 | |||||
841 | This is short-hand for saying that the attribute's type must be an | ||||
842 | object which does the named role. | ||||
843 | |||||
844 | =item * coerce => $bool | ||||
845 | |||||
846 | This option is only valid for objects with a type constraint | ||||
847 | (C<isa>). If this is true, then coercions will be applied whenever | ||||
848 | this attribute is set. | ||||
849 | |||||
850 | You can make both this and the C<weak_ref> option true. | ||||
851 | |||||
852 | =item * trigger => $sub | ||||
853 | |||||
854 | This option accepts a subroutine reference, which will be called after | ||||
855 | the attribute is set. | ||||
856 | |||||
857 | =item * required => $bool | ||||
858 | |||||
859 | An attribute which is required must be provided to the constructor. An | ||||
860 | attribute which is required can also have a C<default> or C<builder>, | ||||
861 | which will satisfy its required-ness. | ||||
862 | |||||
863 | A required attribute must have a C<default>, C<builder> or a | ||||
864 | non-C<undef> C<init_arg> | ||||
865 | |||||
866 | =item * lazy => $bool | ||||
867 | |||||
868 | A lazy attribute must have a C<default> or C<builder>. When an | ||||
869 | attribute is lazy, the default value will not be calculated until the | ||||
870 | attribute is read. | ||||
871 | |||||
872 | =item * weak_ref => $bool | ||||
873 | |||||
874 | If this is true, the attribute's value will be stored as a weak | ||||
875 | reference. | ||||
876 | |||||
877 | =item * auto_deref => $bool | ||||
878 | |||||
879 | If this is true, then the reader will dereference the value when it is | ||||
880 | called. The attribute must have a type constraint which defines the | ||||
881 | attribute as an array or hash reference. | ||||
882 | |||||
883 | =item * lazy_build => $bool | ||||
884 | |||||
885 | Setting this to true makes the attribute lazy and provides a number of | ||||
886 | default methods. | ||||
887 | |||||
888 | has 'size' => ( | ||||
889 | is => 'ro', | ||||
890 | lazy_build => 1, | ||||
891 | ); | ||||
892 | |||||
893 | is equivalent to this: | ||||
894 | |||||
895 | has 'size' => ( | ||||
896 | is => 'ro', | ||||
897 | lazy => 1, | ||||
898 | builder => '_build_size', | ||||
899 | clearer => 'clear_size', | ||||
900 | predicate => 'has_size', | ||||
901 | ); | ||||
902 | |||||
903 | =item * documentation | ||||
904 | |||||
905 | An arbitrary string that can be retrieved later by calling C<< | ||||
906 | $attr->documentation >>. | ||||
907 | |||||
908 | =back | ||||
909 | |||||
910 | =item B<< $attr->clone(%options) >> | ||||
911 | |||||
912 | This creates a new attribute based on attribute being cloned. You must | ||||
913 | supply a C<name> option to provide a new name for the attribute. | ||||
914 | |||||
915 | The C<%options> can only specify options handled by | ||||
916 | L<Class::MOP::Attribute>. | ||||
917 | |||||
918 | =back | ||||
919 | |||||
920 | =head2 Value management | ||||
921 | |||||
922 | =over 4 | ||||
923 | |||||
924 | =item B<< $attr->initialize_instance_slot($meta_instance, $instance, $params) >> | ||||
925 | |||||
926 | This method is used internally to initialize the attribute's slot in | ||||
927 | the object C<$instance>. | ||||
928 | |||||
929 | This overrides the L<Class::MOP::Attribute> method to handle lazy | ||||
930 | attributes, weak references, and type constraints. | ||||
931 | |||||
932 | =item B<get_value> | ||||
933 | |||||
934 | =item B<set_value> | ||||
935 | |||||
936 | eval { $point->meta->get_attribute('x')->set_value($point, 'forty-two') }; | ||||
937 | if($@) { | ||||
938 | print "Oops: $@\n"; | ||||
939 | } | ||||
940 | |||||
941 | I<Attribute (x) does not pass the type constraint (Int) with 'forty-two'> | ||||
942 | |||||
943 | Before setting the value, a check is made on the type constraint of | ||||
944 | the attribute, if it has one, to see if the value passes it. If the | ||||
945 | value fails to pass, the set operation dies with a L<throw_error>. | ||||
946 | |||||
947 | Any coercion to convert values is done before checking the type constraint. | ||||
948 | |||||
949 | To check a value against a type constraint before setting it, fetch the | ||||
950 | attribute instance using L<Class::MOP::Class/find_attribute_by_name>, | ||||
951 | fetch the type_constraint from the attribute using L<Moose::Meta::Attribute/type_constraint> | ||||
952 | and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::Basics::Recipe4> | ||||
953 | for an example. | ||||
954 | |||||
955 | =back | ||||
956 | |||||
957 | =head2 Attribute Accessor generation | ||||
958 | |||||
959 | =over 4 | ||||
960 | |||||
961 | =item B<< $attr->install_accessors >> | ||||
962 | |||||
963 | This method overrides the parent to also install delegation methods. | ||||
964 | |||||
965 | If, after installing all methods, the attribute object has no associated | ||||
966 | methods, it throws an error unless C<< is => 'bare' >> was passed to the | ||||
967 | attribute constructor. (Trying to add an attribute that has no associated | ||||
968 | methods is almost always an error.) | ||||
969 | |||||
970 | =item B<< $attr->remove_accessors >> | ||||
971 | |||||
972 | This method overrides the parent to also remove delegation methods. | ||||
973 | |||||
974 | =item B<< $attr->install_delegation >> | ||||
975 | |||||
976 | This method adds its delegation methods to the attribute's associated | ||||
977 | class, if it has any to add. | ||||
978 | |||||
979 | =item B<< $attr->remove_delegation >> | ||||
980 | |||||
981 | This method remove its delegation methods from the attribute's | ||||
982 | associated class. | ||||
983 | |||||
984 | =item B<< $attr->accessor_metaclass >> | ||||
985 | |||||
986 | Returns the accessor metaclass name, which defaults to | ||||
987 | L<Moose::Meta::Method::Accessor>. | ||||
988 | |||||
989 | =item B<< $attr->delegation_metaclass >> | ||||
990 | |||||
991 | Returns the delegation metaclass name, which defaults to | ||||
992 | L<Moose::Meta::Method::Delegation>. | ||||
993 | |||||
994 | =back | ||||
995 | |||||
996 | =head2 Additional Moose features | ||||
997 | |||||
998 | These methods are not found in the superclass. They support features | ||||
999 | provided by Moose. | ||||
1000 | |||||
1001 | =over 4 | ||||
1002 | |||||
1003 | =item B<< $attr->does($role) >> | ||||
1004 | |||||
1005 | This indicates whether the I<attribute itself> does the given | ||||
1006 | role. The role can be given as a full class name, or as a resolvable | ||||
1007 | trait name. | ||||
1008 | |||||
1009 | Note that this checks the attribute itself, not its type constraint, | ||||
1010 | so it is checking the attribute's metaclass and any traits applied to | ||||
1011 | the attribute. | ||||
1012 | |||||
1013 | =item B<< Moose::Meta::Class->interpolate_class_and_new($name, %options) >> | ||||
1014 | |||||
1015 | This is an alternate constructor that handles the C<metaclass> and | ||||
1016 | C<traits> options. | ||||
1017 | |||||
1018 | Effectively, this method is a factory that finds or creates the | ||||
1019 | appropriate class for the given C<metaclass> and/or C<traits>. | ||||
1020 | |||||
1021 | Once it has the appropriate class, it will call C<< $class->new($name, | ||||
1022 | %options) >> on that class. | ||||
1023 | |||||
1024 | =item B<< $attr->clone_and_inherit_options(%options) >> | ||||
1025 | |||||
1026 | This method supports the C<has '+foo'> feature. It does various bits | ||||
1027 | of processing on the supplied C<%options> before ultimately calling | ||||
1028 | the C<clone> method. | ||||
1029 | |||||
1030 | One of its main tasks is to make sure that the C<%options> provided | ||||
1031 | only includes the options returned by the | ||||
1032 | C<legal_options_for_inheritance> method. | ||||
1033 | |||||
1034 | =item B<< $attr->legal_options_for_inheritance >> | ||||
1035 | |||||
1036 | This returns a whitelist of options that can be overridden in a | ||||
1037 | subclass's attribute definition. | ||||
1038 | |||||
1039 | This exists to allow a custom metaclass to change or add to the list | ||||
1040 | of options which can be changed. | ||||
1041 | |||||
1042 | =item B<< $attr->type_constraint >> | ||||
1043 | |||||
1044 | Returns the L<Moose::Meta::TypeConstraint> object for this attribute, | ||||
1045 | if it has one. | ||||
1046 | |||||
1047 | =item B<< $attr->has_type_constraint >> | ||||
1048 | |||||
1049 | Returns true if this attribute has a type constraint. | ||||
1050 | |||||
1051 | =item B<< $attr->verify_against_type_constraint($value) >> | ||||
1052 | |||||
1053 | Given a value, this method returns true if the value is valid for the | ||||
1054 | attribute's type constraint. If the value is not valid, it throws an | ||||
1055 | error. | ||||
1056 | |||||
1057 | =item B<< $attr->handles >> | ||||
1058 | |||||
1059 | This returns the value of the C<handles> option passed to the | ||||
1060 | constructor. | ||||
1061 | |||||
1062 | =item B<< $attr->has_handles >> | ||||
1063 | |||||
1064 | Returns true if this attribute performs delegation. | ||||
1065 | |||||
1066 | =item B<< $attr->is_weak_ref >> | ||||
1067 | |||||
1068 | Returns true if this attribute stores its value as a weak reference. | ||||
1069 | |||||
1070 | =item B<< $attr->is_required >> | ||||
1071 | |||||
1072 | Returns true if this attribute is required to have a value. | ||||
1073 | |||||
1074 | =item B<< $attr->is_lazy >> | ||||
1075 | |||||
1076 | Returns true if this attribute is lazy. | ||||
1077 | |||||
1078 | =item B<< $attr->is_lazy_build >> | ||||
1079 | |||||
1080 | Returns true if the C<lazy_build> option was true when passed to the | ||||
1081 | constructor. | ||||
1082 | |||||
1083 | =item B<< $attr->should_coerce >> | ||||
1084 | |||||
1085 | Returns true if the C<coerce> option passed to the constructor was | ||||
1086 | true. | ||||
1087 | |||||
1088 | =item B<< $attr->should_auto_deref >> | ||||
1089 | |||||
1090 | Returns true if the C<auto_deref> option passed to the constructor was | ||||
1091 | true. | ||||
1092 | |||||
1093 | =item B<< $attr->trigger >> | ||||
1094 | |||||
1095 | This is the subroutine reference that was in the C<trigger> option | ||||
1096 | passed to the constructor, if any. | ||||
1097 | |||||
1098 | =item B<< $attr->has_trigger >> | ||||
1099 | |||||
1100 | Returns true if this attribute has a trigger set. | ||||
1101 | |||||
1102 | =item B<< $attr->documentation >> | ||||
1103 | |||||
1104 | Returns the value that was in the C<documentation> option passed to | ||||
1105 | the constructor, if any. | ||||
1106 | |||||
1107 | =item B<< $attr->has_documentation >> | ||||
1108 | |||||
1109 | Returns true if this attribute has any documentation. | ||||
1110 | |||||
1111 | =item B<< $attr->applied_traits >> | ||||
1112 | |||||
1113 | This returns an array reference of all the traits which were applied | ||||
1114 | to this attribute. If none were applied, this returns C<undef>. | ||||
1115 | |||||
1116 | =item B<< $attr->has_applied_traits >> | ||||
1117 | |||||
1118 | Returns true if this attribute has any traits applied. | ||||
1119 | |||||
1120 | =back | ||||
1121 | |||||
1122 | =head1 BUGS | ||||
1123 | |||||
1124 | See L<Moose/BUGS> for details on reporting bugs. | ||||
1125 | |||||
1126 | =head1 AUTHOR | ||||
1127 | |||||
1128 | Stevan Little E<lt>stevan@iinteractive.comE<gt> | ||||
1129 | |||||
1130 | Yuval Kogman E<lt>nothingmuch@woobling.comE<gt> | ||||
1131 | |||||
1132 | =head1 COPYRIGHT AND LICENSE | ||||
1133 | |||||
1134 | Copyright 2006-2010 by Infinity Interactive, Inc. | ||||
1135 | |||||
1136 | L<http://www.iinteractive.com> | ||||
1137 | |||||
1138 | This library is free software; you can redistribute it and/or modify | ||||
1139 | it under the same terms as Perl itself. | ||||
1140 | |||||
1141 | =cut | ||||
# spent 9µs within Moose::Meta::Attribute::CORE:sort which was called 5 times, avg 2µs/call:
# 5 times (9µs+0s) by Moose::Meta::Attribute::new at line 63 of Moose/Meta/Attribute.pm, avg 2µs/call |