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