lib/Class/MOP/Attribute.pm

   1
   2 package Class::MOP::Attribute;
   3
   4 use strict;
   5 use warnings;
   6
   7 use Class::MOP::Method::Accessor;
   8
   9 use Carp         'confess';
  10 use Scalar::Util 'blessed', 'weaken';
  11
  12 our $VERSION   = '0.78';
  13 $VERSION = eval $VERSION;
  14 our $AUTHORITY = 'cpan:STEVAN';
  15
  16 use base 'Class::MOP::Object';
  17
  18 # NOTE: (meta-circularity)
  19 # This method will be replaced in the
  20 # boostrap section of Class::MOP, by
  21 # a new version which uses the
  22 # &Class::MOP::Class::construct_instance
  23 # method to build an attribute meta-object
  24 # which itself is described with attribute
  25 # meta-objects.
  26 #     - Ain't meta-circularity grand? :)
  27 sub new {
  28     my ( $class, @args ) = @_;
  29
  30     unshift @args, "name" if @args % 2 == 1;
  31     my %options = @args;
  32
  33     my $name = $options{name};
  34
  35     (defined $name && $name)
  36         || confess "You must provide a name for the attribute";
  37
  38     $options{init_arg} = $name
  39         if not exists $options{init_arg};
  40     if(exists $options{builder}){
  41         confess("builder must be a defined scalar value which is a method name")
  42             if ref $options{builder} || !(defined $options{builder});
  43         confess("Setting both default and builder is not allowed.")
  44             if exists $options{default};
  45     } else {
  46         (is_default_a_coderef(\%options))
  47             || confess("References are not allowed as default values, you must ".
  48                        "wrap the default of '$name' in a CODE reference (ex: sub { [] } and not [])")
  49                 if exists $options{default} && ref $options{default};
  50     }
  51     if( $options{required} and not( defined($options{builder}) || defined($options{init_arg}) || exists $options{default} ) ) {
  52         confess("A required attribute must have either 'init_arg', 'builder', or 'default'");
  53     }
  54
  55     $class->_new(\%options);
  56 }
  57
  58 sub _new {
  59     my $class = shift;
  60     my $options = @_ == 1 ? $_[0] : {@_};
  61
  62     bless {
  63         'name'               => $options->{name},
  64         'accessor'           => $options->{accessor},
  65         'reader'             => $options->{reader},
  66         'writer'             => $options->{writer},
  67         'predicate'          => $options->{predicate},
  68         'clearer'            => $options->{clearer},
  69         'builder'            => $options->{builder},
  70         'init_arg'           => $options->{init_arg},
  71         'default'            => $options->{default},
  72         'initializer'        => $options->{initializer},
  73         'definition_context' => $options->{definition_context},
  74         # keep a weakened link to the
  75         # class we are associated with
  76         'associated_class' => undef,
  77         # and a list of the methods
  78         # associated with this attr
  79         'associated_methods' => [],
  80     }, $class;
  81 }
  82
  83 # NOTE:
  84 # this is a primative (and kludgy) clone operation
  85 # for now, it will be replaced in the Class::MOP
  86 # bootstrap with a proper one, however we know
  87 # that this one will work fine for now.
  88 sub clone {
  89     my $self    = shift;
  90     my %options = @_;
  91     (blessed($self))
  92         || confess "Can only clone an instance";
  93     return bless { %{$self}, %options } => ref($self);
  94 }
  95
  96 sub initialize_instance_slot {
  97     my ($self, $meta_instance, $instance, $params) = @_;
  98     my $init_arg = $self->{'init_arg'};
  99
 100     # try to fetch the init arg from the %params ...
 101
 102     # if nothing was in the %params, we can use the
 103     # attribute's default value (if it has one)
 104     if(defined $init_arg and exists $params->{$init_arg}){
 105         $self->_set_initial_slot_value(
 106             $meta_instance,
 107             $instance,
 108             $params->{$init_arg},
 109         );
 110     }
 111     elsif (defined $self->{'default'}) {
 112         $self->_set_initial_slot_value(
 113             $meta_instance,
 114             $instance,
 115             $self->default($instance),
 116         );
 117     }
 118     elsif (defined( my $builder = $self->{'builder'})) {
 119         if ($builder = $instance->can($builder)) {
 120             $self->_set_initial_slot_value(
 121                 $meta_instance,
 122                 $instance,
 123                 $instance->$builder,
 124             );
 125         }
 126         else {
 127             confess(ref($instance)." does not support builder method '". $self->{'builder'} ."' for attribute '" . $self->name . "'");
 128         }
 129     }
 130 }
 131
 132 sub _set_initial_slot_value {
 133     my ($self, $meta_instance, $instance, $value) = @_;
 134
 135     my $slot_name = $self->name;
 136
 137     return $meta_instance->set_slot_value($instance, $slot_name, $value)
 138         unless $self->has_initializer;
 139
 140     my $callback = sub {
 141         $meta_instance->set_slot_value($instance, $slot_name, $_[0]);
 142     };
 143
 144     my $initializer = $self->initializer;
 145
 146     # most things will just want to set a value, so make it first arg
 147     $instance->$initializer($value, $callback, $self);
 148 }
 149
 150 # NOTE:
 151 # the next bunch of methods will get bootstrapped
 152 # away in the Class::MOP bootstrapping section
 153
 154 sub associated_class   { $_[0]->{'associated_class'}   }
 155 sub associated_methods { $_[0]->{'associated_methods'} }
 156
 157 sub has_accessor    { defined($_[0]->{'accessor'}) }
 158 sub has_reader      { defined($_[0]->{'reader'}) }
 159 sub has_writer      { defined($_[0]->{'writer'}) }
 160 sub has_predicate   { defined($_[0]->{'predicate'}) }
 161 sub has_clearer     { defined($_[0]->{'clearer'}) }
 162 sub has_builder     { defined($_[0]->{'builder'}) }
 163 sub has_init_arg    { defined($_[0]->{'init_arg'}) }
 164 sub has_default     { defined($_[0]->{'default'}) }
 165 sub has_initializer { defined($_[0]->{'initializer'}) }
 166
 167 sub accessor           { $_[0]->{'accessor'}    }
 168 sub reader             { $_[0]->{'reader'}      }
 169 sub writer             { $_[0]->{'writer'}      }
 170 sub predicate          { $_[0]->{'predicate'}   }
 171 sub clearer            { $_[0]->{'clearer'}     }
 172 sub builder            { $_[0]->{'builder'}     }
 173 sub init_arg           { $_[0]->{'init_arg'}    }
 174 sub initializer        { $_[0]->{'initializer'} }
 175 sub definition_context { $_[0]->{'definition_context'} }
 176
 177 # end bootstrapped away method section.
 178 # (all methods below here are kept intact)
 179
 180 sub has_read_method  { $_[0]->has_reader || $_[0]->has_accessor }
 181 sub has_write_method { $_[0]->has_writer || $_[0]->has_accessor }
 182
 183 sub get_read_method  {
 184     my $self   = shift;
 185     my $reader = $self->reader || $self->accessor;
 186     # normal case ...
 187     return $reader unless ref $reader;
 188     # the HASH ref case
 189     my ($name) = %$reader;
 190     return $name;
 191 }
 192
 193 sub get_write_method {
 194     my $self   = shift;
 195     my $writer = $self->writer || $self->accessor;
 196     # normal case ...
 197     return $writer unless ref $writer;
 198     # the HASH ref case
 199     my ($name) = %$writer;
 200     return $name;
 201 }
 202
 203 sub get_read_method_ref {
 204     my $self = shift;
 205     if ((my $reader = $self->get_read_method) && $self->associated_class) {
 206         return $self->associated_class->get_method($reader);
 207     }
 208     else {
 209         my $code = sub { $self->get_value(@_) };
 210         if (my $class = $self->associated_class) {
 211             return $class->method_metaclass->wrap(
 212                 $code,
 213                 package_name => $class->name,
 214                 name         => '__ANON__'
 215             );
 216         }
 217         else {
 218             return $code;
 219         }
 220     }
 221 }
 222
 223 sub get_write_method_ref {
 224     my $self = shift;
 225     if ((my $writer = $self->get_write_method) && $self->associated_class) {
 226         return $self->associated_class->get_method($writer);
 227     }
 228     else {
 229         my $code = sub { $self->set_value(@_) };
 230         if (my $class = $self->associated_class) {
 231             return $class->method_metaclass->wrap(
 232                 $code,
 233                 package_name => $class->name,
 234                 name         => '__ANON__'
 235             );
 236         }
 237         else {
 238             return $code;
 239         }
 240     }
 241 }
 242
 243 sub is_default_a_coderef {
 244     ('CODE' eq ref($_[0]->{'default'}))
 245 }
 246
 247 sub default {
 248     my ($self, $instance) = @_;
 249     if (defined $instance && $self->is_default_a_coderef) {
 250         # if the default is a CODE ref, then
 251         # we pass in the instance and default
 252         # can return a value based on that
 253         # instance. Somewhat crude, but works.
 254         return $self->{'default'}->($instance);
 255     }
 256     $self->{'default'};
 257 }
 258
 259 # slots
 260
 261 sub slots { (shift)->name }
 262
 263 # class association
 264
 265 sub attach_to_class {
 266     my ($self, $class) = @_;
 267     (blessed($class) && $class->isa('Class::MOP::Class'))
 268         || confess "You must pass a Class::MOP::Class instance (or a subclass)";
 269     weaken($self->{'associated_class'} = $class);
 270 }
 271
 272 sub detach_from_class {
 273     my $self = shift;
 274     $self->{'associated_class'} = undef;
 275 }
 276
 277 # method association
 278
 279 sub associate_method {
 280     my ($self, $method) = @_;
 281     push @{$self->{'associated_methods'}} => $method;
 282 }
 283
 284 ## Slot management
 285
 286 sub set_initial_value {
 287     my ($self, $instance, $value) = @_;
 288     $self->_set_initial_slot_value(
 289         Class::MOP::Class->initialize(ref($instance))->get_meta_instance,
 290         $instance,
 291         $value
 292     );
 293 }
 294
 295 sub set_value {
 296     my ($self, $instance, $value) = @_;
 297
 298     Class::MOP::Class->initialize(ref($instance))
 299                      ->get_meta_instance
 300                      ->set_slot_value($instance, $self->name, $value);
 301 }
 302
 303 sub get_value {
 304     my ($self, $instance) = @_;
 305
 306     Class::MOP::Class->initialize(ref($instance))
 307                      ->get_meta_instance
 308                      ->get_slot_value($instance, $self->name);
 309 }
 310
 311 sub has_value {
 312     my ($self, $instance) = @_;
 313
 314     Class::MOP::Class->initialize(ref($instance))
 315                      ->get_meta_instance
 316                      ->is_slot_initialized($instance, $self->name);
 317 }
 318
 319 sub clear_value {
 320     my ($self, $instance) = @_;
 321
 322     Class::MOP::Class->initialize(ref($instance))
 323                      ->get_meta_instance
 324                      ->deinitialize_slot($instance, $self->name);
 325 }
 326
 327 ## load em up ...
 328
 329 sub accessor_metaclass { 'Class::MOP::Method::Accessor' }
 330
 331 sub process_accessors {
 332     warn 'The process_accessors method has been made private.'
 333         . " The public version is deprecated and will be removed in a future release.\n";
 334     goto &_process_accessors;
 335 }
 336
 337 sub _process_accessors {
 338     my ($self, $type, $accessor, $generate_as_inline_methods) = @_;
 339
 340     my $method_ctx;
 341
 342     if ( my $ctx = $self->definition_context ) {
 343         $method_ctx = { %$ctx };
 344     }
 345
 346     if (ref($accessor)) {
 347         (ref($accessor) eq 'HASH')
 348             || confess "bad accessor/reader/writer/predicate/clearer format, must be a HASH ref";
 349         my ($name, $method) = %{$accessor};
 350         $method = $self->accessor_metaclass->wrap(
 351             $method,
 352             package_name => $self->associated_class->name,
 353             name         => $name,
 354             definition_context => $method_ctx,
 355         );
 356         $self->associate_method($method);
 357         return ($name, $method);
 358     }
 359     else {
 360         my $inline_me = ($generate_as_inline_methods && $self->associated_class->instance_metaclass->is_inlinable);
 361         my $method;
 362         eval {
 363             if ( $method_ctx ) {
 364                 my $desc = "accessor $accessor";
 365                 if ( $accessor ne $self->name ) {
 366                     $desc .= " of attribute " . $self->name;
 367                 }
 368
 369                 $method_ctx->{description} = $desc;
 370             }
 371
 372             $method = $self->accessor_metaclass->new(
 373                 attribute     => $self,
 374                 is_inline     => $inline_me,
 375                 accessor_type => $type,
 376                 package_name  => $self->associated_class->name,
 377                 name          => $accessor,
 378                 definition_context => $method_ctx,
 379             );
 380         };
 381         confess "Could not create the '$type' method for " . $self->name . " because : $@" if $@;
 382         $self->associate_method($method);
 383         return ($accessor, $method);
 384     }
 385 }
 386
 387 sub install_accessors {
 388     my $self   = shift;
 389     my $inline = shift;
 390     my $class  = $self->associated_class;
 391
 392     $class->add_method(
 393         $self->_process_accessors('accessor' => $self->accessor(), $inline)
 394     ) if $self->has_accessor();
 395
 396     $class->add_method(
 397         $self->_process_accessors('reader' => $self->reader(), $inline)
 398     ) if $self->has_reader();
 399
 400     $class->add_method(
 401         $self->_process_accessors('writer' => $self->writer(), $inline)
 402     ) if $self->has_writer();
 403
 404     $class->add_method(
 405         $self->_process_accessors('predicate' => $self->predicate(), $inline)
 406     ) if $self->has_predicate();
 407
 408     $class->add_method(
 409         $self->_process_accessors('clearer' => $self->clearer(), $inline)
 410     ) if $self->has_clearer();
 411
 412     return;
 413 }
 414
 415 {
 416     my $_remove_accessor = sub {
 417         my ($accessor, $class) = @_;
 418         if (ref($accessor) && ref($accessor) eq 'HASH') {
 419             ($accessor) = keys %{$accessor};
 420         }
 421         my $method = $class->get_method($accessor);
 422         $class->remove_method($accessor)
 423             if (ref($method) && $method->isa('Class::MOP::Method::Accessor'));
 424     };
 425
 426     sub remove_accessors {
 427         my $self = shift;
 428         # TODO:
 429         # we really need to make sure to remove from the
 430         # associates methods here as well. But this is
 431         # such a slimly used method, I am not worried
 432         # about it right now.
 433         $_remove_accessor->($self->accessor(),  $self->associated_class()) if $self->has_accessor();
 434         $_remove_accessor->($self->reader(),    $self->associated_class()) if $self->has_reader();
 435         $_remove_accessor->($self->writer(),    $self->associated_class()) if $self->has_writer();
 436         $_remove_accessor->($self->predicate(), $self->associated_class()) if $self->has_predicate();
 437         $_remove_accessor->($self->clearer(),   $self->associated_class()) if $self->has_clearer();
 438         return;
 439     }
 440
 441 }
 442
 443 1;
 444
 445 __END__
 446
 447 =pod
 448
 449 =head1 NAME
 450
 451 Class::MOP::Attribute - Attribute Meta Object
 452
 453 =head1 SYNOPSIS
 454
 455   Class::MOP::Attribute->new(
 456       foo => (
 457           accessor  => 'foo',           # dual purpose get/set accessor
 458           predicate => 'has_foo',       # predicate check for defined-ness
 459           init_arg  => '-foo',          # class->new will look for a -foo key
 460           default   => 'BAR IS BAZ!'    # if no -foo key is provided, use this
 461       )
 462   );
 463
 464   Class::MOP::Attribute->new(
 465       bar => (
 466           reader    => 'bar',           # getter
 467           writer    => 'set_bar',       # setter
 468           predicate => 'has_bar',       # predicate check for defined-ness
 469           init_arg  => ':bar',          # class->new will look for a :bar key
 470                                         # no default value means it is undef
 471       )
 472   );
 473
 474 =head1 DESCRIPTION
 475
 476 The Attribute Protocol is almost entirely an invention of
 477 C<Class::MOP>. Perl 5 does not have a consistent notion of
 478 attributes. There are so many ways in which this is done, and very few
 479 (if any) are easily discoverable by this module.
 480
 481 With that said, this module attempts to inject some order into this
 482 chaos, by introducing a consistent API which can be used to create
 483 object attributes.
 484
 485 =head1 METHODS
 486
 487 =head2 Creation
 488
 489 =over 4
 490
 491 =item B<< Class::MOP::Attribute->new($name, ?%options) >>
 492
 493 An attribute must (at the very least), have a C<$name>. All other
 494 C<%options> are added as key-value pairs.
 495
 496 =over 8
 497
 498 =item I<init_arg>
 499
 500 This is a string value representing the expected key in an
 501 initialization hash. For instance, if we have an C<init_arg> value of
 502 C<-foo>, then the following code will Just Work.
 503
 504   MyClass->meta->construct_instance( -foo => 'Hello There' );
 505
 506 If an init_arg is not assigned, it will automatically use the
 507 attribute's name. If C<init_arg> is explicitly set to C<undef>, the
 508 attribute cannot be specified during initialization.
 509
 510 =item I<builder>
 511
 512 This provides the name of a method that will be called to initialize
 513 the attribute. This method will be called on the object after it is
 514 constructed. It is expected to return a valid value for the attribute.
 515
 516 =item I<default>
 517
 518 This can be used to provide an explicit default for initializing the
 519 attribute. If the default you provide is a subroutine reference, then
 520 this reference will be called I<as a method> on the object.
 521
 522 If the value is a simple scalar (string or number), then it can be
 523 just passed as is. However, if you wish to initialize it with a HASH
 524 or ARRAY ref, then you need to wrap that inside a subroutine
 525 reference:
 526
 527   Class::MOP::Attribute->new(
 528       'foo' => (
 529           default => sub { [] },
 530       )
 531   );
 532
 533   # or ...
 534
 535   Class::MOP::Attribute->new(
 536       'foo' => (
 537           default => sub { {} },
 538       )
 539   );
 540
 541 If you wish to initialize an attribute with a subroutine reference
 542 itself, then you need to wrap that in a subroutine as well:
 543
 544   Class::MOP::Attribute->new(
 545       'foo' => (
 546           default => sub {
 547               sub { print "Hello World" }
 548           },
 549       )
 550   );
 551
 552 And lastly, if the value of your attribute is dependent upon some
 553 other aspect of the instance structure, then you can take advantage of
 554 the fact that when the C<default> value is called as a method:
 555
 556   Class::MOP::Attribute->new(
 557       'object_identity' => (
 558           default => sub { Scalar::Util::refaddr( $_[0] ) },
 559       )
 560   );
 561
 562 Note that there is no guarantee that attributes are initialized in any
 563 particular order, so you cannot rely on the value of some other
 564 attribute when generating the default.
 565
 566 =item I<initializer>
 567
 568 This option can be either a method name or a subroutine
 569 reference. This method will be called when setting the attribute's
 570 value in the constructor. Unlike C<default> and C<builder>, the
 571 initializer is only called when a value is provided to the
 572 constructor. The initializer allows you to munge this value during
 573 object construction.
 574
 575 The initializer is called as a method with three arguments. The first
 576 is the value that was passed to the constructor. The second is a
 577 subroutine reference that can be called to actually set the
 578 attribute's value, and the last is the associated
 579 C<Class::MOP::Attribute> object.
 580
 581 This contrived example shows an initializer that sets the attribute to
 582 twice the given value.
 583
 584   Class::MOP::Attribute->new(
 585       'doubled' => (
 586           initializer => sub {
 587               my ( $instance, $value, $set ) = @_;
 588               $set->( $value * 2 );
 589           },
 590       )
 591   );
 592
 593 Since an initializer can be a method name, you can easily make
 594 attribute initialization use the writer:
 595
 596   Class::MOP::Attribute->new(
 597       'some_attr' => (
 598           writer      => 'some_attr',
 599           initializer => 'some_attr',
 600       )
 601   );
 602
 603 Your writer will need to examine C<@_> and determine under which
 604 context it is being called.
 605
 606 =back
 607
 608 The C<accessor>, C<reader>, C<writer>, C<predicate> and C<clearer>
 609 options all accept the same parameters. You can provide the name of
 610 the method, in which case an appropriate default method will be
 611 generated for you. Or instead you can also provide hash reference
 612 containing exactly one key (the method name) and one value. The value
 613 should be a subroutine reference, which will be installed as the
 614 method itself.
 615
 616 =over 4
 617
 618 =item I<accessor>
 619
 620 An C<accessor> is a standard Perl-style read/write accessor. It will
 621 return the value of the attribute, and if a value is passed as an
 622 argument, it will assign that value to the attribute.
 623
 624 Note that C<undef> is a legitimate value, so this will work:
 625
 626   $object->set_something(undef);
 627
 628 =item I<reader>
 629
 630 This is a basic read-only accessor. It returns the value of the
 631 attribute.
 632
 633 =item I<writer>
 634
 635 This is a basic write accessor, it accepts a single argument, and
 636 assigns that value to the attribute.
 637
 638 Note that C<undef> is a legitimate value, so this will work:
 639
 640   $object->set_something(undef);
 641
 642 =item I<predicate>
 643
 644 The predicate method returns a boolean indicating whether or not the
 645 attribute has been explicitly set.
 646
 647 Note that the predicate returns true even if the attribute was set to
 648 a false value (C<0> or C<undef>).
 649
 650 =item I<clearer>
 651
 652 This method will uninitialize the attribute. After an attribute is
 653 cleared, its C<predicate> will return false.
 654
 655 =item I<definition_context>
 656
 657 Mostly, this exists as a hook for the benefit of Moose.
 658
 659 This option should be a hash reference containing several keys which
 660 will be used when inlining the attribute's accessors. The keys should
 661 include C<line>, the line number where the attribute was created, and
 662 either C<file> or C<description>.
 663
 664 This information will ultimately be used when eval'ing inlined
 665 accessor code so that error messages report a useful line and file
 666 name.
 667
 668 =back
 669
 670 =item B<< $attr->clone(%options) >>
 671
 672 This clones the attribute. Any options you provide will override the
 673 settings of the original attribute. You can change the name of the new
 674 attribute by passing a C<name> key in C<%options>.
 675
 676 =back
 677
 678 =head2 Informational
 679
 680 These are all basic read-only accessors for the values passed into
 681 the constructor.
 682
 683 =over 4
 684
 685 =item B<< $attr->name >>
 686
 687 =item B<< $attr->accessor >>
 688
 689 =item B<< $attr->reader >>
 690
 691 =item B<< $attr->writer >>
 692
 693 =item B<< $attr->predicate >>
 694
 695 =item B<< $attr->clearer >>
 696
 697 The C<accessor>, C<reader>, C<writer>, C<predicate>, and C<clearer>
 698 methods all return exactly what was passed to the constructor, so it
 699 can be either a string containing a method name, or a hash reference.
 700
 701 =item B<< $attr->initializer >>
 702
 703 Returns the initializer as passed to the constructor, so this may be
 704 either a method name or a subroutine reference.
 705
 706 =item B<< $attr->init_arg >>
 707
 708 =item B<< $attr->is_default_a_coderef >>
 709
 710 =item B<< $attr->default($instance) >>
 711
 712 The C<$instance> argument is optional. If you don't pass it, the
 713 return value for this method is exactly what was passed to the
 714 constructor, either a simple scalar or a subroutine reference.
 715
 716 If you I<do> pass an C<$instance> and the default is a subroutine
 717 reference, then the reference is called as a method on the
 718 C<$instance> and the generated value is returned.
 719
 720 =item B<< $attr->slots >>
 721
 722 Return a list of slots required by the attribute. This is usually just
 723 one, the name of the attribute.
 724
 725 A slot is the name of the hash key used to store the attribute in an
 726 object instance.
 727
 728 =item B<< $attr->get_read_method >>
 729
 730 =item B<< $attr->get_write_method >>
 731
 732 Returns the name of a method suitable for reading or writing the value
 733 of the attribute in the associated class.
 734
 735 If an attribute is read- or write-only, then these methods can return
 736 C<undef> as appropriate.
 737
 738 =item B<< $attr->has_read_method >>
 739
 740 =item B<< $attr->has_write_method >>
 741
 742 This returns a boolean indicating whether the attribute has a I<named>
 743 read or write method.
 744
 745 =item B<< $attr->get_read_method_ref >>
 746
 747 =item B<< $attr->get_write_method_ref >>
 748
 749 Returns the subroutine reference of a method suitable for reading or
 750 writing the attribute's value in the associated class. These methods
 751 always return a subroutine reference, regardless of whether or not the
 752 attribute is read- or write-only.
 753
 754 =back
 755
 756 =head2 Informational predicates
 757
 758 These are all basic predicate methods for the values passed into C<new>.
 759
 760 =over 4
 761
 762 =item B<< $attr->has_accessor >>
 763
 764 =item B<< $attr->has_reader >>
 765
 766 =item B<< $attr->has_writer >>
 767
 768 =item B<< $attr->has_predicate >>
 769
 770 =item B<< $attr->has_clearer >>
 771
 772 =item B<< $attr->has_initializer >>
 773
 774 =item B<< $attr->has_init_arg >>
 775
 776 This will be I<false> if the C<init_arg> was set to C<undef>.
 777
 778 =item B<< $attr->has_default >>
 779
 780 This will be I<false> if the C<default> was set to C<undef>, since
 781 C<undef> is the default C<default> anyway.
 782
 783 =item B<< $attr->has_builder >>
 784
 785 =back
 786
 787 =head2 Value management
 788
 789 These methods are basically "back doors" to the instance, and can be
 790 used to bypass the regular accessors, but still stay within the MOP.
 791
 792 These methods are not for general use, and should only be used if you
 793 really know what you are doing.
 794
 795 =over 4
 796
 797 =item B<< $attr->initialize_instance_slot($meta_instance, $instance, $params) >>
 798
 799 This method is used internally to initialize the attribute's slot in
 800 the object C<$instance>.
 801
 802 The C<$params> is a hash reference of the values passed to the object
 803 constructor.
 804
 805 It's unlikely that you'll need to call this method yourself.
 806
 807 =item B<< $attr->set_value($instance, $value) >>
 808
 809 Sets the value without going through the accessor. Note that this
 810 works even with read-only attributes.
 811
 812 =item B<< $attr->set_initial_value($instance, $value) >>
 813
 814 Sets the value without going through the accessor. This method is only
 815 called when the instance is first being initialized.
 816
 817 =item B<< $attr->get_value($instance) >>
 818
 819 Returns the value without going through the accessor. Note that this
 820 works even with write-only accessors.
 821
 822 =item B<< $attr->has_value($instance) >>
 823
 824 Return a boolean indicating whether the attribute has been set in
 825 C<$instance>. This how the default C<predicate> method works.
 826
 827 =item B<< $attr->clear_value($instance) >>
 828
 829 This will clear the attribute's value in C<$instance>. This is what
 830 the default C<clearer> calls.
 831
 832 Note that this works even if the attribute does not have any
 833 associated read, write or clear methods.
 834
 835 =back
 836
 837 =head2 Class association
 838
 839 These methods allow you to manage the attributes association with
 840 the class that contains it. These methods should not be used
 841 lightly, nor are they very magical, they are mostly used internally
 842 and by metaclass instances.
 843
 844 =over 4
 845
 846 =item B<< $attr->associated_class >>
 847
 848 This returns the C<Class::MOP::Class> with which this attribute is
 849 associated, if any.
 850
 851 =item B<< $attr->attach_to_class($metaclass) >>
 852
 853 This method stores a weakened reference to the C<$metaclass> object
 854 internally.
 855
 856 This method does not remove the attribute from its old class,
 857 nor does it create any accessors in the new class.
 858
 859 It is probably best to use the L<Class::MOP::Class> C<add_attribute>
 860 method instead.
 861
 862 =item B<< $attr->detach_from_class >>
 863
 864 This method removes the associate metaclass object from the attribute
 865 it has one.
 866
 867 This method does not remove the attribute itself from the class, or
 868 remove its accessors.
 869
 870 It is probably best to use the L<Class::MOP::Class>
 871 C<remove_attribute> method instead.
 872
 873 =back
 874
 875 =head2 Attribute Accessor generation
 876
 877 =over 4
 878
 879 =item B<< $attr->accessor_metaclass >>
 880
 881 Accessor methods are generated using an accessor metaclass. By
 882 default, this is L<Class::MOP::Method::Accessor>. This method returns
 883 the name of the accessor metaclass that this attribute uses.
 884
 885 =item B<< $attr->associate_method($method) >>
 886
 887 This associates a L<Class::MOP::Method> object with the
 888 attribute. Typically, this is called internally when an attribute
 889 generates its accessors.
 890
 891 =item B<< $attr->associated_methods >>
 892
 893 This returns the list of methods which have been associated with the
 894 attribute.
 895
 896 =item B<< $attr->install_accessors >>
 897
 898 This method generates and installs code the attributes various
 899 accessors. It is typically called from the L<Class::MOP::Class>
 900 C<add_attribute> method.
 901
 902 =item B<< $attr->remove_accessors >>
 903
 904 This method removes all of the accessors associated with the
 905 attribute.
 906
 907 This does not currently remove methods from the list returned by
 908 C<associated_methods>.
 909
 910 =back
 911
 912 =head2 Introspection
 913
 914 =over 4
 915
 916 =item B<< $attr->meta >>
 917
 918 This will return a L<Class::MOP::Class> instance for this class.
 919
 920 It should also be noted that L<Class::MOP> will actually bootstrap
 921 this module by installing a number of attribute meta-objects into its
 922 metaclass.
 923
 924 =back
 925
 926 =head1 AUTHORS
 927
 928 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 929
 930 =head1 COPYRIGHT AND LICENSE
 931
 932 Copyright 2006-2009 by Infinity Interactive, Inc.
 933
 934 L<http://www.iinteractive.com>
 935
 936 This library is free software; you can redistribute it and/or modify
 937 it under the same terms as Perl itself.
 938
 939 =cut
 940
 941