use Carp 'confess';
use Scalar::Util 'blessed', 'reftype', 'weaken';
-our $VERSION = '0.17';
+our $VERSION = '0.23';
our $AUTHORITY = 'cpan:STEVAN';
use base 'Class::MOP::Object';
"wrap then in a CODE reference (ex: sub { [] } and not [])")
if exists $options{default} && ref $options{default};
}
+ if( $options{required} and not( defined($options{builder}) || defined($options{init_arg}) || exists $options{default} ) ) {
+ confess("A required attribute must have either 'init_arg', 'builder', or 'default'");
+ }
bless {
'$!name' => $name,
'$!accessor' => $options{accessor},
'$!reader' => $options{reader},
+ # NOTE:
+ # protect this from silliness
+ init_arg => '!............( DO NOT DO THIS )............!',
'$!writer' => $options{writer},
'$!predicate' => $options{predicate},
'$!clearer' => $options{clearer},
# keep a weakened link to the
# class we are associated with
'$!associated_class' => undef,
+ '$!initializer' => $options{initializer},
# and a list of the methods
# associated with this attr
'@!associated_methods' => [],
# if nothing was in the %params, we can use the
# attribute's default value (if it has one)
- if(exists $params->{$init_arg}){
- $meta_instance->set_slot_value($instance, $self->name, $params->{$init_arg});
+ if(defined $init_arg and exists $params->{$init_arg}){
+ $meta_instance->_set_initial_slot_value(
+ $instance,
+ $self->name,
+ $params->{$init_arg},
+ $self->initializer,
+ );
}
elsif (defined $self->{'$!default'}) {
- $meta_instance->set_slot_value($instance, $self->name, $self->default($instance));
+ $meta_instance->_set_initial_slot_value(
+ $instance,
+ $self->name,
+ $self->default($instance),
+ $self->initializer,
+ );
}
elsif (defined( my $builder = $self->{'$!builder'})) {
if ($builder = $instance->can($builder)) {
- $meta_instance->set_slot_value($instance, $self->name, $instance->$builder);
+ $meta_instance->_set_initial_slot_value(
+ $instance,
+ $self->name,
+ $instance->$builder,
+ $self->initializer,
+ );
}
else {
confess(blessed($instance)." does not support builder method '". $self->{'$!builder'} ."' for attribute '" . $self->name . "'");
sub has_builder { defined($_[0]->{'$!builder'}) ? 1 : 0 }
sub has_init_arg { defined($_[0]->{'$!init_arg'}) ? 1 : 0 }
sub has_default { defined($_[0]->{'$!default'}) ? 1 : 0 }
+sub has_initializer { defined($_[0]->{'$!initializer'}) ? 1 : 0 }
sub accessor { $_[0]->{'$!accessor'} }
sub reader { $_[0]->{'$!reader'} }
sub clearer { $_[0]->{'$!clearer'} }
sub builder { $_[0]->{'$!builder'} }
sub init_arg { $_[0]->{'$!init_arg'} }
+sub initializer { $_[0]->{'$!initializer'} }
# end bootstrapped away method section.
# (all methods below here are kept intact)
-sub get_read_method { $_[0]->reader || $_[0]->accessor }
-sub get_write_method { $_[0]->writer || $_[0]->accessor }
+sub get_read_method {
+ my $self = shift;
+ my $reader = $self->reader || $self->accessor;
+ # normal case ...
+ return $reader unless ref $reader;
+ # the HASH ref case
+ my ($name) = %$reader;
+ return $name;
+}
+
+sub get_write_method {
+ my $self = shift;
+ my $writer = $self->writer || $self->accessor;
+ # normal case ...
+ return $writer unless ref $writer;
+ # the HASH ref case
+ my ($name) = %$writer;
+ return $name;
+}
+
+sub get_read_method_ref {
+ my $self = shift;
+ if ((my $reader = $self->get_read_method) && $self->associated_class) {
+ return $self->associated_class->get_method($reader);
+ }
+ else {
+ return sub { $self->get_value(@_) };
+ }
+}
+
+sub get_write_method_ref {
+ my $self = shift;
+ if ((my $writer = $self->get_write_method) && $self->associated_class) {
+ return $self->associated_class->get_method($writer);
+ }
+ else {
+ return sub { $self->set_value(@_) };
+ }
+}
sub is_default_a_coderef {
('CODE' eq (reftype($_[0]->{'$!default'} || $_[0]->{default}) || ''))
## Slot management
+sub set_initial_value {
+ my ($self, $instance, $value) = @_;
+
+ Class::MOP::Class->initialize(blessed($instance))
+ ->get_meta_instance
+ ->_set_initial_slot_value($instance, $self->name, $value, $self->initializer);
+}
+
sub set_value {
my ($self, $instance, $value) = @_;
In an init_arg is not assigned, it will automatically use the
value of C<$name>.
-=item I<default>
-
-The value of this key is the default value which
-C<Class::MOP::Class::construct_instance> will initialize the
-attribute to.
-
=item I<builder>
The value of this key is the name of the method that will be
This should be a method in the class associated with the attribute,
not a method in the attribute class itself.
+=item I<default>
+
+The value of this key is the default value which
+C<Class::MOP::Class::construct_instance> will initialize the
+attribute to.
+
B<NOTE:>
If the value is a simple scalar (string or number), then it can
be just passed as is. However, if you wish to initialize it with
=item I<predicate>
-This is a basic test to see if the value of the attribute is not
-C<undef>. It will return true (C<1>) if the attribute's value is
-defined, and false (C<0>) otherwise.
+This is a basic test to see if any value has been set for the
+attribute. It will return true (C<1>) if the attribute has been set
+to any value (even C<undef>), and false (C<0>) otherwise.
+
+B<NOTE:>
+The predicate will return true even when you set an attribute's
+value to C<undef>. This behaviour has changed as of version 0.43. In
+older versions, the predicate (erroneously) checked for attribute
+value definedness, instead of presence as it is now.
+
+If you really want to get rid of the value, you have to define and
+use a I<clearer> (see below).
+
=item I<clearer>
Set the value without going through the accessor. Note that this may be done to
even attributes with just read only accessors.
+=item B<set_initial_value ($instance, $value)>
+
+This method sets the value without going through the accessor -- but it is only
+called when the instance data is first initialized.
+
=item B<get_value ($instance)>
Return the value without going through the accessor. Note that this may be done
=item B<has_value ($instance)>
-Returns a boolean indicating if the item in the C<$instance> has a value in it.
+Return a boolean indicating if the item in the C<$instance> has a value in it.
This is basically what the default C<predicate> method calls.
=item B<clear_value ($instance)>
=item B<clearer>
+=item B<initializer>
+
=item B<init_arg>
=item B<is_default_a_coderef>
=item B<default (?$instance)>
-As noted in the documentation for C<new> above, if the I<default>
-value is a CODE reference, this accessor will pass a single additional
-argument C<$instance> into it and return the value.
+Return the default value for the attribute.
+
+If you pass in an C<$instance> argument to this accessor and the
+I<default> is a CODE reference, then the CODE reference will be
+executed with the C<$instance> as its argument.
=item B<slots>
-Returns a list of slots required by the attribute. This is usually
+Return a list of slots required by the attribute. This is usually
just one, which is the name of the attribute.
=item B<get_read_method>
=item B<get_write_method>
-Return the name of a method suitable for reading / writing the value of the
-attribute in the associated class. Suitable for use whether C<reader> and
-C<writer> or C<accessor> was used.
+Return the name of a method name suitable for reading / writing the value
+of the attribute in the associated class. Suitable for use whether
+C<reader> and C<writer> or C<accessor> was used.
+
+=item B<get_read_method_ref>
+
+=item B<get_write_method_ref>
+
+Return the CODE reference of a method suitable for reading / writing the
+value of the attribute in the associated class. Suitable for use whether
+C<reader> and C<writer> or C<accessor> was specified or not.
+
+NOTE: If not reader/writer/accessor was specified, this will use the
+attribute get_value/set_value methods, which can be very inefficient.
=back
=item B<has_clearer>
+=item B<has_initializer>
+
=item B<has_init_arg>
=item B<has_default>
=head1 COPYRIGHT AND LICENSE
-Copyright 2006, 2007 by Infinity Interactive, Inc.
+Copyright 2006-2008 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>