lib/Moose/Meta/Attribute.pm

   1
   2 package Moose::Meta::Attribute;
   3
   4 use strict;
   5 use warnings;
   6
   7 use Scalar::Util 'blessed', 'weaken', 'reftype';
   8 use Carp         'confess';
   9 use Sub::Name    'subname';
  10 use overload     ();
  11
  12 our $VERSION   = '0.22';
  13 our $AUTHORITY = 'cpan:STEVAN';
  14
  15 use Moose::Meta::Method::Accessor;
  16 use Moose::Util::TypeConstraints ();
  17
  18 use base 'Class::MOP::Attribute';
  19
  20 # options which are not directly used
  21 # but we store them for metadata purposes
  22 __PACKAGE__->meta->add_attribute('isa'  => (reader    => '_isa_metadata'));
  23 __PACKAGE__->meta->add_attribute('does' => (reader    => '_does_metadata'));
  24 __PACKAGE__->meta->add_attribute('is'   => (reader    => '_is_metadata'));
  25
  26 # these are actual options for the attrs
  27 __PACKAGE__->meta->add_attribute('required'   => (reader => 'is_required'      ));
  28 __PACKAGE__->meta->add_attribute('lazy'       => (reader => 'is_lazy'          ));
  29 __PACKAGE__->meta->add_attribute('lazy_build' => (reader => 'is_lazy_build'    ));
  30 __PACKAGE__->meta->add_attribute('coerce'     => (reader => 'should_coerce'    ));
  31 __PACKAGE__->meta->add_attribute('weak_ref'   => (reader => 'is_weak_ref'      ));
  32 __PACKAGE__->meta->add_attribute('auto_deref' => (reader => 'should_auto_deref'));
  33 __PACKAGE__->meta->add_attribute('type_constraint' => (
  34     reader    => 'type_constraint',
  35     predicate => 'has_type_constraint',
  36 ));
  37 __PACKAGE__->meta->add_attribute('trigger' => (
  38     reader    => 'trigger',
  39     predicate => 'has_trigger',
  40 ));
  41 __PACKAGE__->meta->add_attribute('handles' => (
  42     reader    => 'handles',
  43     predicate => 'has_handles',
  44 ));
  45 __PACKAGE__->meta->add_attribute('documentation' => (
  46     reader    => 'documentation',
  47     predicate => 'has_documentation',
  48 ));
  49 __PACKAGE__->meta->add_attribute('traits' => (
  50     reader    => 'applied_traits',
  51     predicate => 'has_applied_traits',
  52 ));
  53
  54 # NOTE:
  55 # we need to have a ->does method in here to
  56 # more easily support traits, and the introspection
  57 # of those traits. So in order to do this we
  58 # just alias Moose::Object's version of it.
  59 # - SL
  60 *does = \&Moose::Object::does;
  61
  62 sub new {
  63     my ($class, $name, %options) = @_;
  64     $class->_process_options($name, \%options);
  65     return $class->SUPER::new($name, %options);
  66 }
  67
  68 sub clone_and_inherit_options {
  69     my ($self, %options) = @_;
  70     # you can change default, required, coerce, documentation, lazy, handles, builder, metaclass and traits
  71     my %actual_options;
  72     foreach my $legal_option (qw(default coerce required documentation lazy handles builder metaclass traits)) {
  73         if (exists $options{$legal_option}) {
  74             $actual_options{$legal_option} = $options{$legal_option};
  75             delete $options{$legal_option};
  76         }
  77     }
  78
  79     if ($options{isa}) {
  80         my $type_constraint;
  81         if (blessed($options{isa}) && $options{isa}->isa('Moose::Meta::TypeConstraint')) {
  82             $type_constraint = $options{isa};
  83         }
  84         else {
  85             $type_constraint = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options{isa});
  86             (defined $type_constraint)
  87                 || confess "Could not find the type constraint '" . $options{isa} . "'";
  88         }
  89
  90         $actual_options{type_constraint} = $type_constraint;
  91         delete $options{isa};
  92     }
  93
  94     if ($options{does}) {
  95         my $type_constraint;
  96         if (blessed($options{does}) && $options{does}->isa('Moose::Meta::TypeConstraint')) {
  97             $type_constraint = $options{does};
  98         }
  99         else {
 100             $type_constraint = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options{does});
 101             (defined $type_constraint)
 102                 || confess "Could not find the type constraint '" . $options{does} . "'";
 103         }
 104
 105         $actual_options{type_constraint} = $type_constraint;
 106         delete $options{does};
 107     }
 108
 109     (scalar keys %options == 0)
 110         || confess "Illegal inherited options => (" . (join ', ' => keys %options) . ")";
 111     $self->clone(%actual_options);
 112 }
 113
 114 sub _process_options {
 115     my ($class, $name, $options) = @_;
 116
 117     if (exists $options->{is}) {
 118         if ($options->{is} eq 'ro') {
 119             $options->{reader} ||= $name;
 120             (!exists $options->{trigger})
 121                 || confess "Cannot have a trigger on a read-only attribute $name";
 122         }
 123         elsif ($options->{is} eq 'rw') {
 124             $options->{accessor} = $name;
 125             ((reftype($options->{trigger}) || '') eq 'CODE')
 126                 || confess "Trigger must be a CODE ref"
 127                     if exists $options->{trigger};
 128         }
 129         else {
 130             confess "I do not understand this option (is => " . $options->{is} . ") on attribute $name"
 131         }
 132     }
 133
 134     if (exists $options->{isa}) {
 135         if (exists $options->{does}) {
 136             if (eval { $options->{isa}->can('does') }) {
 137                 ($options->{isa}->does($options->{does}))
 138                     || confess "Cannot have an isa option and a does option if the isa does not do the does on attribute $name";
 139             }
 140             else {
 141                 confess "Cannot have an isa option which cannot ->does() on attribute $name";
 142             }
 143         }
 144
 145         # allow for anon-subtypes here ...
 146         if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) {
 147             $options->{type_constraint} = $options->{isa};
 148         }
 149         else {
 150             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_isa_type_constraint($options->{isa});
 151         }
 152     }
 153     elsif (exists $options->{does}) {
 154         # allow for anon-subtypes here ...
 155         if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
 156                 $options->{type_constraint} = $options->{does};
 157         }
 158         else {
 159             $options->{type_constraint} = Moose::Util::TypeConstraints::find_or_create_does_type_constraint($options->{does});
 160         }
 161     }
 162
 163     if (exists $options->{coerce} && $options->{coerce}) {
 164         (exists $options->{type_constraint})
 165             || confess "You cannot have coercion without specifying a type constraint on attribute $name";
 166         confess "You cannot have a weak reference to a coerced value on attribute $name"
 167             if $options->{weak_ref};
 168     }
 169
 170     if (exists $options->{auto_deref} && $options->{auto_deref}) {
 171         (exists $options->{type_constraint})
 172             || confess "You cannot auto-dereference without specifying a type constraint on attribute $name";
 173         ($options->{type_constraint}->is_a_type_of('ArrayRef') ||
 174          $options->{type_constraint}->is_a_type_of('HashRef'))
 175             || confess "You cannot auto-dereference anything other than a ArrayRef or HashRef on attribute $name";
 176     }
 177
 178     if (exists $options->{lazy_build} && $options->{lazy_build} == 1) {
 179         confess("You can not use lazy_build and default for the same attribute $name")
 180             if exists $options->{default};
 181         $options->{lazy}      = 1;
 182         $options->{required}  = 1;
 183         $options->{builder} ||= "_build_${name}";
 184         if ($name =~ /^_/) {
 185             $options->{clearer}   ||= "_clear${name}";
 186             $options->{predicate} ||= "_has${name}";
 187         }
 188         else {
 189             $options->{clearer}   ||= "clear_${name}";
 190             $options->{predicate} ||= "has_${name}";
 191         }
 192     }
 193
 194     if (exists $options->{lazy} && $options->{lazy}) {
 195         (exists $options->{default} || defined $options->{builder} )
 196             || confess "You cannot have lazy attribute ($name) without specifying a default value for it";
 197     }
 198
 199     if ( $options->{required} && !( ( !exists $options->{init_arg} || defined $options->{init_arg} ) || exists $options->{default} || defined $options->{builder} ) ) {
 200         confess "You cannot have a required attribute ($name) without a default, builder, or an init_arg";
 201     }
 202
 203 }
 204
 205 sub initialize_instance_slot {
 206     my ($self, $meta_instance, $instance, $params) = @_;
 207     my $init_arg = $self->init_arg();
 208     # try to fetch the init arg from the %params ...
 209
 210     my $val;
 211     my $value_is_set;
 212     if ( defined($init_arg) and exists $params->{$init_arg}) {
 213         $val = $params->{$init_arg};
 214         $value_is_set = 1;
 215     }
 216     else {
 217         # skip it if it's lazy
 218         return if $self->is_lazy;
 219         # and die if it's required and doesn't have a default value
 220         confess "Attribute (" . $self->name . ") is required"
 221             if $self->is_required && !$self->has_default && !$self->has_builder;
 222
 223         # if nothing was in the %params, we can use the
 224         # attribute's default value (if it has one)
 225         if ($self->has_default) {
 226             $val = $self->default($instance);
 227             $value_is_set = 1;
 228         }
 229         elsif ($self->has_builder) {
 230             if (my $builder = $instance->can($self->builder)){
 231                 $val = $instance->$builder;
 232                 $value_is_set = 1;
 233             }
 234             else {
 235                 confess(blessed($instance)." does not support builder method '".$self->builder."' for attribute '" . $self->name . "'");
 236             }
 237         }
 238     }
 239
 240     return unless $value_is_set;
 241
 242     if ($self->has_type_constraint) {
 243         my $type_constraint = $self->type_constraint;
 244         if ($self->should_coerce && $type_constraint->has_coercion) {
 245             $val = $type_constraint->coerce($val);
 246         }
 247         $type_constraint->check($val)
 248             || confess "Attribute ("
 249                      . $self->name
 250                      . ") does not pass the type constraint because: "
 251                      . $type_constraint->get_message($val);
 252     }
 253
 254     $self->set_initial_value($instance, $val);
 255     $meta_instance->weaken_slot_value($instance, $self->name)
 256         if ref $val && $self->is_weak_ref;
 257 }
 258
 259 ## Slot management
 260
 261 # FIXME:
 262 # this duplicates too much code from
 263 # Class::MOP::Attribute, we need to
 264 # refactor these bits eventually.
 265 # - SL
 266 sub _set_initial_slot_value {
 267     my ($self, $meta_instance, $instance, $value) = @_;
 268
 269     my $slot_name = $self->name;
 270
 271     return $meta_instance->set_slot_value($instance, $slot_name, $value)
 272         unless $self->has_initializer;
 273
 274     my ($type_constraint, $can_coerce);
 275     if ($self->has_type_constraint) {
 276         $type_constraint = $self->type_constraint;
 277         $can_coerce      = ($self->should_coerce && $type_constraint->has_coercion);
 278     }
 279
 280     my $callback = sub {
 281         my $val = shift;
 282         if ($type_constraint) {
 283             $val = $type_constraint->coerce($val)
 284                 if $can_coerce;
 285             $type_constraint->check($val)
 286                 || confess "Attribute ("
 287                          . $slot_name
 288                          . ") does not pass the type constraint because: "
 289                          . $type_constraint->get_message($val);
 290         }
 291         $meta_instance->set_slot_value($instance, $slot_name, $val);
 292     };
 293
 294     my $initializer = $self->initializer;
 295
 296     # most things will just want to set a value, so make it first arg
 297     $instance->$initializer($value, $callback, $self);
 298 }
 299
 300 sub set_value {
 301     my ($self, $instance, $value) = @_;
 302
 303     my $attr_name = $self->name;
 304
 305     if ($self->is_required) {
 306         defined($value)
 307             || confess "Attribute ($attr_name) is required, so cannot be set to undef";
 308     }
 309
 310     if ($self->has_type_constraint) {
 311
 312         my $type_constraint = $self->type_constraint;
 313
 314         if ($self->should_coerce) {
 315             $value = $type_constraint->coerce($value);
 316         }
 317         $type_constraint->_compiled_type_constraint->($value)
 318             || confess "Attribute ("
 319                      . $self->name
 320                      . ") does not pass the type constraint because "
 321                      . $type_constraint->get_message($value);
 322     }
 323
 324     my $meta_instance = Class::MOP::Class->initialize(blessed($instance))
 325                                          ->get_meta_instance;
 326
 327     $meta_instance->set_slot_value($instance, $attr_name, $value);
 328
 329     if (ref $value && $self->is_weak_ref) {
 330         $meta_instance->weaken_slot_value($instance, $attr_name);
 331     }
 332
 333     if ($self->has_trigger) {
 334         $self->trigger->($instance, $value, $self);
 335     }
 336 }
 337
 338 sub get_value {
 339     my ($self, $instance) = @_;
 340
 341     if ($self->is_lazy) {
 342         unless ($self->has_value($instance)) {
 343             if ($self->has_default) {
 344                 my $default = $self->default($instance);
 345                 $self->set_initial_value($instance, $default);
 346             }
 347             if ( $self->has_builder ){
 348                 if (my $builder = $instance->can($self->builder)){
 349                     $self->set_initial_value($instance, $instance->$builder);
 350                 }
 351                 else {
 352                     confess(blessed($instance)
 353                           . " does not support builder method '"
 354                           . $self->builder
 355                           . "' for attribute '"
 356                           . $self->name
 357                           . "'");
 358                 }
 359             }
 360             else {
 361                 $self->set_initial_value($instance, undef);
 362             }
 363         }
 364     }
 365
 366     if ($self->should_auto_deref) {
 367
 368         my $type_constraint = $self->type_constraint;
 369
 370         if ($type_constraint->is_a_type_of('ArrayRef')) {
 371             my $rv = $self->SUPER::get_value($instance);
 372             return unless defined $rv;
 373             return wantarray ? @{ $rv } : $rv;
 374         }
 375         elsif ($type_constraint->is_a_type_of('HashRef')) {
 376             my $rv = $self->SUPER::get_value($instance);
 377             return unless defined $rv;
 378             return wantarray ? %{ $rv } : $rv;
 379         }
 380         else {
 381             confess "Can not auto de-reference the type constraint '" . $type_constraint->name . "'";
 382         }
 383
 384     }
 385     else {
 386
 387         return $self->SUPER::get_value($instance);
 388     }
 389 }
 390
 391 ## installing accessors
 392
 393 sub accessor_metaclass { 'Moose::Meta::Method::Accessor' }
 394
 395 sub install_accessors {
 396     my $self = shift;
 397     $self->SUPER::install_accessors(@_);
 398
 399     if ($self->has_handles) {
 400
 401         # NOTE:
 402         # Here we canonicalize the 'handles' option
 403         # this will sort out any details and always
 404         # return an hash of methods which we want
 405         # to delagate to, see that method for details
 406         my %handles = $self->_canonicalize_handles();
 407
 408         # find the accessor method for this attribute
 409         my $accessor = $self->get_read_method_ref;
 410         # then unpack it if we need too ...
 411         $accessor = $accessor->body if blessed $accessor;
 412
 413         # install the delegation ...
 414         my $associated_class = $self->associated_class;
 415         foreach my $handle (keys %handles) {
 416             my $method_to_call = $handles{$handle};
 417             my $class_name = $associated_class->name;
 418             my $name = "${class_name}::${handle}";
 419
 420             (!$associated_class->has_method($handle))
 421                 || confess "You cannot overwrite a locally defined method ($handle) with a delegation";
 422
 423             # NOTE:
 424             # handles is not allowed to delegate
 425             # any of these methods, as they will
 426             # override the ones in your class, which
 427             # is almost certainly not what you want.
 428
 429             # FIXME warn when $handle was explicitly specified, but not if the source is a regex or something
 430             #cluck("Not delegating method '$handle' because it is a core method") and
 431             next if $class_name->isa("Moose::Object") and $handle =~ /^BUILD|DEMOLISH$/ || Moose::Object->can($handle);
 432
 433             if ((reftype($method_to_call) || '') eq 'CODE') {
 434                 $associated_class->add_method($handle => subname $name, $method_to_call);
 435             }
 436             else {
 437                 # NOTE:
 438                 # we used to do a goto here, but the
 439                 # goto didn't handle failure correctly
 440                 # (it just returned nothing), so I took
 441                 # that out. However, the more I thought
 442                 # about it, the less I liked it doing
 443                 # the goto, and I prefered the act of
 444                 # delegation being actually represented
 445                 # in the stack trace.
 446                 # - SL
 447                 $associated_class->add_method($handle => subname $name, sub {
 448                     my $proxy = (shift)->$accessor();
 449                     (defined $proxy)
 450                         || confess "Cannot delegate $handle to $method_to_call because " .
 451                                    "the value of " . $self->name . " is not defined";
 452                     $proxy->$method_to_call(@_);
 453                 });
 454             }
 455         }
 456     }
 457
 458     return;
 459 }
 460
 461 # private methods to help delegation ...
 462
 463 sub _canonicalize_handles {
 464     my $self    = shift;
 465     my $handles = $self->handles;
 466     if (my $handle_type = ref($handles)) {
 467         if ($handle_type eq 'HASH') {
 468             return %{$handles};
 469         }
 470         elsif ($handle_type eq 'ARRAY') {
 471             return map { $_ => $_ } @{$handles};
 472         }
 473         elsif ($handle_type eq 'Regexp') {
 474             ($self->has_type_constraint)
 475                 || confess "Cannot delegate methods based on a RegExpr without a type constraint (isa)";
 476             return map  { ($_ => $_) }
 477                    grep { /$handles/ } $self->_get_delegate_method_list;
 478         }
 479         elsif ($handle_type eq 'CODE') {
 480             return $handles->($self, $self->_find_delegate_metaclass);
 481         }
 482         else {
 483             confess "Unable to canonicalize the 'handles' option with $handles";
 484         }
 485     }
 486     else {
 487         my $role_meta = eval { $handles->meta };
 488         if ($@) {
 489             confess "Unable to canonicalize the 'handles' option with $handles because : $@";
 490         }
 491
 492         (blessed $role_meta && $role_meta->isa('Moose::Meta::Role'))
 493             || confess "Unable to canonicalize the 'handles' option with $handles because ->meta is not a Moose::Meta::Role";
 494
 495         return map { $_ => $_ } (
 496             $role_meta->get_method_list,
 497             $role_meta->get_required_method_list
 498         );
 499     }
 500 }
 501
 502 sub _find_delegate_metaclass {
 503     my $self = shift;
 504     if (my $class = $self->_isa_metadata) {
 505         # if the class does have
 506         # a meta method, use it
 507         return $class->meta if $class->can('meta');
 508         # otherwise we might be
 509         # dealing with a non-Moose
 510         # class, and need to make
 511         # our own metaclass
 512         return Moose::Meta::Class->initialize($class);
 513     }
 514     elsif (my $role = $self->_does_metadata) {
 515         # our role will always have
 516         # a meta method
 517         return $role->meta;
 518     }
 519     else {
 520         confess "Cannot find delegate metaclass for attribute " . $self->name;
 521     }
 522 }
 523
 524 sub _get_delegate_method_list {
 525     my $self = shift;
 526     my $meta = $self->_find_delegate_metaclass;
 527     if ($meta->isa('Class::MOP::Class')) {
 528         return map  { $_->{name}                     }  # NOTE: !never! delegate &meta
 529                grep { $_->{class} ne 'Moose::Object' && $_->{name} ne 'meta' }
 530                     $meta->compute_all_applicable_methods;
 531     }
 532     elsif ($meta->isa('Moose::Meta::Role')) {
 533         return $meta->get_method_list;
 534     }
 535     else {
 536         confess "Unable to recognize the delegate metaclass '$meta'";
 537     }
 538 }
 539
 540 1;
 541
 542 __END__
 543
 544 =pod
 545
 546 =head1 NAME
 547
 548 Moose::Meta::Attribute - The Moose attribute metaclass
 549
 550 =head1 DESCRIPTION
 551
 552 This is a subclass of L<Class::MOP::Attribute> with Moose specific
 553 extensions.
 554
 555 For the most part, the only time you will ever encounter an
 556 instance of this class is if you are doing some serious deep
 557 introspection. To really understand this class, you need to refer
 558 to the L<Class::MOP::Attribute> documentation.
 559
 560 =head1 METHODS
 561
 562 =head2 Overridden methods
 563
 564 These methods override methods in L<Class::MOP::Attribute> and add
 565 Moose specific features. You can safely assume though that they
 566 will behave just as L<Class::MOP::Attribute> does.
 567
 568 =over 4
 569
 570 =item B<new>
 571
 572 =item B<does>
 573
 574 =item B<initialize_instance_slot>
 575
 576 =item B<install_accessors>
 577
 578 =item B<accessor_metaclass>
 579
 580 =item B<get_value>
 581
 582 =item B<set_value>
 583
 584   eval { $point->meta->get_attribute('x')->set_value($point, 'fourty-two') };
 585   if($@) {
 586     print "Oops: $@\n";
 587   }
 588
 589 I<Attribute (x) does not pass the type constraint (Int) with 'fourty-two'>
 590
 591 Before setting the value, a check is made on the type constraint of
 592 the attribute, if it has one, to see if the value passes it. If the
 593 value fails to pass, the set operation dies with a L<Carp/confess>.
 594
 595 Any coercion to convert values is done before checking the type constraint.
 596
 597 To check a value against a type constraint before setting it, fetch the
 598 attribute instance using L<Class::MOP::Class/find_attribute_by_name>,
 599 fetch the type_constraint from the attribute using L<Moose::Meta::Attribute/type_constraint>
 600 and call L<Moose::Meta::TypeConstraint/check>. See L<Moose::Cookbook::RecipeX>
 601 for an example.
 602
 603 =back
 604
 605 =head2 Additional Moose features
 606
 607 Moose attributes support type-constraint checking, weak reference
 608 creation and type coercion.
 609
 610 =over 4
 611
 612 =item B<clone_and_inherit_options>
 613
 614 This is to support the C<has '+foo'> feature, it clones an attribute
 615 from a superclass and allows a very specific set of changes to be made
 616 to the attribute.
 617
 618 =item B<has_type_constraint>
 619
 620 Returns true if this meta-attribute has a type constraint.
 621
 622 =item B<type_constraint>
 623
 624 A read-only accessor for this meta-attribute's type constraint. For
 625 more information on what you can do with this, see the documentation
 626 for L<Moose::Meta::TypeConstraint>.
 627
 628 =item B<has_handles>
 629
 630 Returns true if this meta-attribute performs delegation.
 631
 632 =item B<handles>
 633
 634 This returns the value which was passed into the handles option.
 635
 636 =item B<is_weak_ref>
 637
 638 Returns true if this meta-attribute produces a weak reference.
 639
 640 =item B<is_required>
 641
 642 Returns true if this meta-attribute is required to have a value.
 643
 644 =item B<is_lazy>
 645
 646 Returns true if this meta-attribute should be initialized lazily.
 647
 648 NOTE: lazy attributes, B<must> have a C<default> or C<builder> field set.
 649
 650 =item B<is_lazy_build>
 651
 652 Returns true if this meta-attribute should be initialized lazily through
 653 the builder generated by lazy_build. Using C<lazy_build =E<gt> 1> will
 654 make your attribute required and lazy. In addition it will set the builder, clearer
 655 and predicate options for you using the following convention.
 656
 657    #If your attribute name starts with an underscore:
 658    has '_foo' => (lazy_build => 1);
 659    #is the same as
 660    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', builder => '_build__foo);
 661    # or
 662    has '_foo' => (lazy => 1, required => 1, predicate => '_has_foo', clearer => '_clear_foo', default => sub{shift->_build__foo});
 663
 664    #If your attribute name does not start with an underscore:
 665    has 'foo' => (lazy_build => 1);
 666    #is the same as
 667    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', builder => '_build_foo);
 668    # or
 669    has 'foo' => (lazy => 1, required => 1, predicate => 'has_foo', clearer => 'clear_foo', default => sub{shift->_build_foo});
 670
 671 The reason for the different naming of the C<builder> is that the C<builder>
 672 method is a private method while the C<clearer> and C<predicate> methods
 673 are public methods.
 674
 675 NOTE: This means your class should provide a method whose name matches the value
 676 of the builder part, in this case _build__foo or _build_foo.
 677
 678 =item B<should_coerce>
 679
 680 Returns true if this meta-attribute should perform type coercion.
 681
 682 =item B<should_auto_deref>
 683
 684 Returns true if this meta-attribute should perform automatic
 685 auto-dereferencing.
 686
 687 NOTE: This can only be done for attributes whose type constraint is
 688 either I<ArrayRef> or I<HashRef>.
 689
 690 =item B<has_trigger>
 691
 692 Returns true if this meta-attribute has a trigger set.
 693
 694 =item B<trigger>
 695
 696 This is a CODE reference which will be executed every time the
 697 value of an attribute is assigned. The CODE ref will get two values,
 698 the invocant and the new value. This can be used to handle I<basic>
 699 bi-directional relations.
 700
 701 =item B<documentation>
 702
 703 This is a string which contains the documentation for this attribute.
 704 It serves no direct purpose right now, but it might in the future
 705 in some kind of automated documentation system perhaps.
 706
 707 =item B<has_documentation>
 708
 709 Returns true if this meta-attribute has any documentation.
 710
 711 =item B<applied_traits>
 712
 713 This will return the ARRAY ref of all the traits applied to this
 714 attribute, or if no traits have been applied, it returns C<undef>.
 715
 716 =item B<has_applied_traits>
 717
 718 Returns true if this meta-attribute has any traits applied.
 719
 720 =back
 721
 722 =head1 BUGS
 723
 724 All complex software has bugs lurking in it, and this module is no
 725 exception. If you find a bug please either email me, or add the bug
 726 to cpan-RT.
 727
 728 =head1 AUTHOR
 729
 730 Stevan Little E<lt>stevan@iinteractive.comE<gt>
 731
 732 Yuval Kogman E<lt>nothingmuch@woobling.comE<gt>
 733
 734 =head1 COPYRIGHT AND LICENSE
 735
 736 Copyright 2006-2008 by Infinity Interactive, Inc.
 737
 738 L<http://www.iinteractive.com>
 739
 740 This library is free software; you can redistribute it and/or modify
 741 it under the same terms as Perl itself.
 742
 743 =cut