X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FClass%2FMOP%2FAttribute.pm;h=941f90a4cc7b4450f2b931566b1933a9860ffaef;hb=804f7d24a1d915091c94017734c78ab5cbdfa181;hp=c8ab6c0c925674134e5729774d299ce30ac1a37d;hpb=3545c727b64808e435c361e061962d14ba5b3f31;p=gitmo%2FClass-MOP.git diff --git a/lib/Class/MOP/Attribute.pm b/lib/Class/MOP/Attribute.pm index c8ab6c0..941f90a 100644 --- a/lib/Class/MOP/Attribute.pm +++ b/lib/Class/MOP/Attribute.pm @@ -9,7 +9,7 @@ use Class::MOP::Method::Accessor; use Carp 'confess'; use Scalar::Util 'blessed', 'reftype', 'weaken'; -our $VERSION = '0.12'; +our $VERSION = '0.14'; our $AUTHORITY = 'cpan:STEVAN'; use base 'Class::MOP::Object'; @@ -45,20 +45,20 @@ sub new { if exists $options{default} && ref $options{default}; bless { - name => $name, - accessor => $options{accessor}, - reader => $options{reader}, - writer => $options{writer}, - predicate => $options{predicate}, - clearer => $options{clearer}, - init_arg => $options{init_arg}, - default => $options{default}, + '$!name' => $name, + '$!accessor' => $options{accessor}, + '$!reader' => $options{reader}, + '$!writer' => $options{writer}, + '$!predicate' => $options{predicate}, + '$!clearer' => $options{clearer}, + '$!init_arg' => $options{init_arg}, + '$!default' => $options{default}, # keep a weakened link to the # class we are associated with - associated_class => undef, + '$!associated_class' => undef, # and a list of the methods # associated with this attr - associated_methods => [], + '@!associated_methods' => [], } => $class; } @@ -77,13 +77,13 @@ sub clone { sub initialize_instance_slot { my ($self, $meta_instance, $instance, $params) = @_; - my $init_arg = $self->{init_arg}; + my $init_arg = $self->{'$!init_arg'}; # try to fetch the init arg from the %params ... my $val; $val = $params->{$init_arg} if exists $params->{$init_arg}; # if nothing was in the %params, we can use the # attribute's default value (if it has one) - if (!defined $val && defined $self->{default}) { + if (!defined $val && defined $self->{'$!default'}) { $val = $self->default($instance); } $meta_instance->set_slot_value($instance, $self->name, $val); @@ -93,43 +93,43 @@ sub initialize_instance_slot { # the next bunch of methods will get bootstrapped # away in the Class::MOP bootstrapping section -sub name { $_[0]->{name} } +sub name { $_[0]->{'$!name'} } -sub associated_class { $_[0]->{associated_class} } -sub associated_methods { $_[0]->{associated_methods} } +sub associated_class { $_[0]->{'$!associated_class'} } +sub associated_methods { $_[0]->{'@!associated_methods'} } -sub has_accessor { defined($_[0]->{accessor}) ? 1 : 0 } -sub has_reader { defined($_[0]->{reader}) ? 1 : 0 } -sub has_writer { defined($_[0]->{writer}) ? 1 : 0 } -sub has_predicate { defined($_[0]->{predicate}) ? 1 : 0 } -sub has_clearer { defined($_[0]->{clearer}) ? 1 : 0 } -sub has_init_arg { defined($_[0]->{init_arg}) ? 1 : 0 } -sub has_default { defined($_[0]->{default}) ? 1 : 0 } +sub has_accessor { defined($_[0]->{'$!accessor'}) ? 1 : 0 } +sub has_reader { defined($_[0]->{'$!reader'}) ? 1 : 0 } +sub has_writer { defined($_[0]->{'$!writer'}) ? 1 : 0 } +sub has_predicate { defined($_[0]->{'$!predicate'}) ? 1 : 0 } +sub has_clearer { defined($_[0]->{'$!clearer'}) ? 1 : 0 } +sub has_init_arg { defined($_[0]->{'$!init_arg'}) ? 1 : 0 } +sub has_default { defined($_[0]->{'$!default'}) ? 1 : 0 } -sub accessor { $_[0]->{accessor} } -sub reader { $_[0]->{reader} } -sub writer { $_[0]->{writer} } -sub predicate { $_[0]->{predicate} } -sub clearer { $_[0]->{clearer} } -sub init_arg { $_[0]->{init_arg} } +sub accessor { $_[0]->{'$!accessor'} } +sub reader { $_[0]->{'$!reader'} } +sub writer { $_[0]->{'$!writer'} } +sub predicate { $_[0]->{'$!predicate'} } +sub clearer { $_[0]->{'$!clearer'} } +sub init_arg { $_[0]->{'$!init_arg'} } # end bootstrapped away method section. # (all methods below here are kept intact) sub is_default_a_coderef { - ('CODE' eq (reftype($_[0]->{default}) || '')) + ('CODE' eq (reftype($_[0]->{'$!default'} || $_[0]->{default}) || '')) } sub default { my ($self, $instance) = @_; - if ($instance && $self->is_default_a_coderef) { + if (defined $instance && $self->is_default_a_coderef) { # if the default is a CODE ref, then # we pass in the instance and default # can return a value based on that # instance. Somewhat crude, but works. - return $self->{default}->($instance); + return $self->{'$!default'}->($instance); } - $self->{default}; + $self->{'$!default'}; } # slots @@ -142,19 +142,19 @@ sub attach_to_class { my ($self, $class) = @_; (blessed($class) && $class->isa('Class::MOP::Class')) || confess "You must pass a Class::MOP::Class instance (or a subclass)"; - weaken($self->{associated_class} = $class); + weaken($self->{'$!associated_class'} = $class); } sub detach_from_class { my $self = shift; - $self->{associated_class} = undef; + $self->{'$!associated_class'} = undef; } # method association sub associate_method { my ($self, $method) = @_; - push @{$self->{associated_methods}} => $method; + push @{$self->{'@!associated_methods'}} => $method; } ## Slot management @@ -211,7 +211,7 @@ sub process_accessors { eval { $method = $self->accessor_metaclass->new( attribute => $self, - as_inline => $inline_me, + is_inline => $inline_me, accessor_type => $type, ); }; @@ -262,6 +262,11 @@ sub install_accessors { sub remove_accessors { my $self = shift; + # TODO: + # we really need to make sure to remove from the + # associates methods here as well. But this is + # such a slimly used method, I am not worried + # about it right now. $_remove_accessor->($self->accessor(), $self->associated_class()) if $self->has_accessor(); $_remove_accessor->($self->reader(), $self->associated_class()) if $self->has_reader(); $_remove_accessor->($self->writer(), $self->associated_class()) if $self->has_writer(); @@ -445,6 +450,12 @@ back to their "unfulfilled" state. =head2 Value management +These methods are basically "backdoors" to the instance, which can be used +to bypass the regular accessors, but still stay within the context of the MOP. + +These methods are not for general use, and should only be used if you really +know what you are doing. + =over 4 =item B @@ -459,8 +470,15 @@ even to attributes with just write only accessors. =item B +Returns a boolean indicating if the item in the C<$instance> has a value in it. +This is basically what the default C method calls. + =item B +This will clear the value in the C<$instance>. This is basically what the default +C would call. Note that this may be done even if the attirbute does not +have any associated read, write or clear methods. + =back =head2 Informational @@ -523,14 +541,32 @@ These are all basic predicate methods for the values passed into C. =head2 Class association +These methods allow you to manage the attributes association with +the class that contains it. These methods should not be used +lightly, nor are they very magical, they are mostly used internally +and by metaclass instances. + =over 4 =item B +This returns the metaclass this attribute is associated with. + =item B +This will store a weaken reference to C<$class> internally. You should +note that just changing the class assocation will not remove the attribute +from it's old class, and initialize it (and it's accessors) in the new +C<$class>. It is up to you to do this manually. + =item B +This will remove the weakened reference to the class. It does B +remove the attribute itself from the class (or remove it's accessors), +you must do that yourself if you want too. Actually if that is what +you want to do, you should probably be looking at +L instead. + =back =head2 Attribute Accessor generation @@ -539,10 +575,20 @@ These are all basic predicate methods for the values passed into C. =item B -=item B +Accessors are generated by an accessor metaclass, which is usually +a subclass of C. This method returns +the name of the accessor metaclass that this attribute uses. + +=item B + +This will associate a C<$method> with the given attribute which is +used internally by the accessor generator. =item B +This will return the list of methods which have been associated with +the C methods. + =item B This allows the attribute to generate and install code for it's own @@ -566,6 +612,9 @@ This allows the attribute to remove the method for it's own I. This is called by C. +NOTE: This does not currently remove methods from the list returned +by C, that is on the TODO list. + =back =head2 Introspection @@ -592,7 +641,7 @@ Yuval Kogman Enothingmuch@woobling.comE =head1 COPYRIGHT AND LICENSE -Copyright 2006 by Infinity Interactive, Inc. +Copyright 2006, 2007 by Infinity Interactive, Inc. L