[gitmo/Moose.git] / lib / Moose / Meta / Attribute.pm


package Moose::Meta::Attribute;

use strict;
use warnings;

use Scalar::Util 'blessed', 'weaken', 'reftype';
use Carp         'confess';

our $VERSION = '0.05';

use Moose::Util::TypeConstraints ();

use base 'Class::MOP::Attribute';

__PACKAGE__->meta->add_attribute('required' => (reader => 'is_required'  ));
__PACKAGE__->meta->add_attribute('lazy'     => (reader => 'is_lazy'      ));
__PACKAGE__->meta->add_attribute('coerce'   => (reader => 'should_coerce'));
__PACKAGE__->meta->add_attribute('weak_ref' => (reader => 'is_weak_ref'  ));
__PACKAGE__->meta->add_attribute('type_constraint' => (
    reader    => 'type_constraint',
    predicate => 'has_type_constraint',
));
__PACKAGE__->meta->add_attribute('trigger' => (
    reader    => 'trigger',
    predicate => 'has_trigger',
));

sub new {
	my ($class, $name, %options) = @_;
	$class->_process_options($name, \%options);
	$class->SUPER::new($name, %options);	
}

sub clone {
	my ($self, %options) = @_;
	$self->_process_options($self->name, \%options);
	$self->SUPER::clone(%options);	
}

sub _process_options {
    my ($class, $name, $options) = @_;
	if (exists $options->{is}) {
		if ($options->{is} eq 'ro') {
			$options->{reader} = $name;
			(!exists $options->{trigger})
			    || confess "Cannot have a trigger on a read-only attribute";
		}
		elsif ($options->{is} eq 'rw') {
			$options->{accessor} = $name;				
			((reftype($options->{trigger}) || '') eq 'CODE')
			    || confess "A trigger must be a CODE reference"
			        if exists $options->{trigger};			
		}			
	}
	
	if (exists $options->{isa}) {
	    
	    if (exists $options->{does}) {
	        if (eval { $options->{isa}->can('does') }) {
	            ($options->{isa}->does($options->{does}))	            
	                || confess "Cannot have an isa option and a does option if the isa does not do the does";
	        }
	        else {
	            confess "Cannot have an isa option which cannot ->does()";
	        }
	    }	    
	    
	    # allow for anon-subtypes here ...
	    if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) {
			$options->{type_constraint} = $options->{isa};
		}
		else {
		    
		    if ($options->{isa} =~ /\|/) {
		        my @type_constraints = split /\s*\|\s*/ => $options->{isa};
		        $options->{type_constraint} = Moose::Util::TypeConstraints::create_type_constraint_union(
		            @type_constraints
		        );
		    }
		    else {
    		    # otherwise assume it is a constraint
    		    my $constraint = Moose::Util::TypeConstraints::find_type_constraint($options->{isa});	    
    		    # if the constraing it not found ....
    		    unless (defined $constraint) {
    		        # assume it is a foreign class, and make 
    		        # an anon constraint for it 
    		        $constraint = Moose::Util::TypeConstraints::subtype(
    		            'Object', 
    		            Moose::Util::TypeConstraints::where { $_->isa($options->{isa}) }
    		        );
    		    }			    
                $options->{type_constraint} = $constraint;
            }
		}
	}	
	elsif (exists $options->{does}) {	    
	    # allow for anon-subtypes here ...
	    if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
			$options->{type_constraint} = $options->{isa};
		}
		else {
		    # otherwise assume it is a constraint
		    my $constraint = Moose::Util::TypeConstraints::find_type_constraint($options->{does});	      
		    # if the constraing it not found ....
		    unless (defined $constraint) {	  		        
		        # assume it is a foreign class, and make 
		        # an anon constraint for it 
		        $constraint = Moose::Util::TypeConstraints::subtype(
		            'Role', 
		            Moose::Util::TypeConstraints::where { $_->does($options->{does}) }
		        );
		    }			    
            $options->{type_constraint} = $constraint;
		}	    
	}
	
	if (exists $options->{coerce} && $options->{coerce}) {
	    (exists $options->{type_constraint})
	        || confess "You cannot have coercion without specifying a type constraint";
	    (!$options->{type_constraint}->isa('Moose::Meta::TypeConstraint::Union'))
	        || confess "You cannot have coercion with a type constraint union";	        
        confess "You cannot have a weak reference to a coerced value"
            if $options->{weak_ref};	        
	}	
	
	if (exists $options->{lazy} && $options->{lazy}) {
	    (exists $options->{default})
	        || confess "You cannot have lazy attribute without specifying a default value for it";	    
	}    
}

sub initialize_instance_slot {
    my ($self, $class, $instance, $params) = @_;
    my $init_arg = $self->init_arg();
    # try to fetch the init arg from the %params ...
    my $val;        
    if (exists $params->{$init_arg}) {
        $val = $params->{$init_arg};
    }
    else {
        # skip it if it's lazy
        return if $self->is_lazy;
        # and die if it's required and doesn't have a default value
        confess "Attribute (" . $self->name . ") is required" 
            if $self->is_required && !$self->has_default;
    }
    # if nothing was in the %params, we can use the 
    # attribute's default value (if it has one)
    if (!defined $val && $self->has_default) {
        $val = $self->default($instance); 
    }
	if (defined $val) {
	    if ($self->has_type_constraint) {
	        my $type_constraint = $self->type_constraint;
		    if ($self->should_coerce && $type_constraint->has_coercion) {
		        $val = $type_constraint->coercion->coerce($val);
		    }	
            (defined($type_constraint->check($val))) 
                || confess "Attribute (" . 
                           $self->name . 
                           ") does not pass the type contraint (" . 
                           $type_constraint->name .
                           ") with '$val'";			
        }
	}
    $instance->{$self->name} = $val;
    if (defined $val && $self->is_weak_ref) {
        weaken($instance->{$self->name});
    }    
}

sub generate_accessor_method {
    my ($self, $attr_name) = @_;
    my $value_name = $self->should_coerce ? '$val' : '$_[1]';
    my $code = 'sub { '
    . 'if (scalar(@_) == 2) {'
        . ($self->is_required ? 
            'defined($_[1]) || confess "Attribute ($attr_name) is required, so cannot be set to undef";' 
            : '')
        . ($self->should_coerce ? 
            'my $val = $self->type_constraint->coercion->coerce($_[1]);'
            : '')
        . ($self->has_type_constraint ? 
            ('(defined $self->type_constraint->check(' . $value_name . '))'
            	. '|| confess "Attribute ($attr_name) does not pass the type contraint (" . $self->type_constraint->name . ") with \'' . $value_name . '\'"'
            		. 'if defined ' . $value_name . ';')
            : '')
        . '$_[0]->{$attr_name} = ' . $value_name . ';'
        . ($self->is_weak_ref ?
            'weaken($_[0]->{$attr_name});'
            : '')
        . ($self->has_trigger ?
            '$self->trigger->($_[0], ' . $value_name . ', $self);'
            : '')            
    . ' }'
    . ($self->is_lazy ? 
            '$_[0]->{$attr_name} = ($self->has_default ? $self->default($_[0]) : undef)'
            . 'unless exists $_[0]->{$attr_name};'
            : '')    
    . ' $_[0]->{$attr_name};'
    . ' }';
    my $sub = eval $code;
    confess "Could not create writer for '$attr_name' because $@ \n code: $code" if $@;
    return $sub;    
}

sub generate_writer_method {
    my ($self, $attr_name) = @_; 
    my $value_name = $self->should_coerce ? '$val' : '$_[1]';
    my $code = 'sub { '
    . ($self->is_required ? 
        'defined($_[1]) || confess "Attribute ($attr_name) is required, so cannot be set to undef";' 
        : '')
    . ($self->should_coerce ? 
        'my $val = $self->type_constraint->coercion->coerce($_[1]);'
        : '')
    . ($self->has_type_constraint ? 
        ('(defined $self->type_constraint->check(' . $value_name . '))'
        	. '|| confess "Attribute ($attr_name) does not pass the type contraint (" . $self->type_constraint->name . ") with \'' . $value_name . '\'"'
        		. 'if defined ' . $value_name . ';')
        : '')
    . '$_[0]->{$attr_name} = ' . $value_name . ';'
    . ($self->is_weak_ref ?
        'weaken($_[0]->{$attr_name});'
        : '')
    . ($self->has_trigger ?
        '$self->trigger->($_[0], ' . $value_name . ', $self);'
        : '')        
    . ' }';
    my $sub = eval $code;
    confess "Could not create writer for '$attr_name' because $@ \n code: $code" if $@;
    return $sub;    
}

sub generate_reader_method {
    my ($self, $attr_name) = @_; 
    my $code = 'sub {'
    . 'confess "Cannot assign a value to a read-only accessor" if @_ > 1;'
    . ($self->is_lazy ? 
            '$_[0]->{$attr_name} = ($self->has_default ? $self->default($_[0]) : undef)'
            . 'unless exists $_[0]->{$attr_name};'
            : '')
    . '$_[0]->{$attr_name};'
    . '}';
    my $sub = eval $code;
    confess "Could not create reader for '$attr_name' because $@ \n code: $code" if $@;
    return $sub;
}

1;

__END__

=pod

=head1 NAME

Moose::Meta::Attribute - The Moose attribute metaclass

=head1 DESCRIPTION

This is a subclass of L<Class::MOP::Attribute> with Moose specific 
extensions. 

For the most part, the only time you will ever encounter an 
instance of this class is if you are doing some serious deep 
introspection. To really understand this class, you need to refer 
to the L<Class::MOP::Attribute> documentation.

=head1 METHODS

=head2 Overridden methods

These methods override methods in L<Class::MOP::Attribute> and add 
Moose specific features. You can safely assume though that they 
will behave just as L<Class::MOP::Attribute> does.

=over 4

=item B<new>

=item B<clone>

=item B<initialize_instance_slot>

=item B<generate_accessor_method>

=item B<generate_writer_method>

=item B<generate_reader_method>

=back

=head2 Additional Moose features

Moose attributes support type-contstraint checking, weak reference 
creation and type coercion.  

=over 4

=item B<has_type_constraint>

Returns true if this meta-attribute has a type constraint.

=item B<type_constraint>

A read-only accessor for this meta-attribute's type constraint. For 
more information on what you can do with this, see the documentation 
for L<Moose::Meta::TypeConstraint>.

=item B<is_weak_ref>

Returns true if this meta-attribute produces a weak reference.

=item B<is_required>

Returns true if this meta-attribute is required to have a value.

=item B<is_lazy>

Returns true if this meta-attribute should be initialized lazily.

NOTE: lazy attributes, B<must> have a C<default> field set.

=item B<should_coerce>

Returns true if this meta-attribute should perform type coercion.

=item B<has_trigger>

Returns true if this meta-attribute has a trigger set.

=item B<trigger>

This is a CODE reference which will be executed every time the 
value of an attribute is assigned. The CODE ref will get two values, 
the invocant and the new value. This can be used to handle I<basic> 
bi-directional relations.

=back

=head1 BUGS

All complex software has bugs lurking in it, and this module is no 
exception. If you find a bug please either email me, or add the bug
to cpan-RT.

=head1 AUTHOR

Stevan Little E<lt>stevan@iinteractive.comE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright 2006 by Infinity Interactive, Inc.

L<http://www.iinteractive.com>

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself. 

=cut
Commit	Line	Data
c0e30cf5	1
	2	package Moose::Meta::Attribute;
	3
	4	use strict;
	5	use warnings;
	6
78cd1d3b	7	use Scalar::Util 'blessed', 'weaken', 'reftype';
a15dff8d	8	use Carp 'confess';
a15dff8d	9
4c4fbe56	10	our $VERSION = '0.05';
78cd1d3b	11
a3c7e2fe	12	use Moose::Util::TypeConstraints ();
bc1e29b5	13
c0e30cf5	14	use base 'Class::MOP::Attribute';
c0e30cf5	15
ca01a97b	16	__PACKAGE__->meta->add_attribute('required' => (reader => 'is_required' ));
ca01a97b	17	__PACKAGE__->meta->add_attribute('lazy' => (reader => 'is_lazy' ));
6ba6d68c	18	__PACKAGE__->meta->add_attribute('coerce' => (reader => 'should_coerce'));
6ba6d68c	19	__PACKAGE__->meta->add_attribute('weak_ref' => (reader => 'is_weak_ref' ));
82168dbb	20	__PACKAGE__->meta->add_attribute('type_constraint' => (
	21	reader => 'type_constraint',
	22	predicate => 'has_type_constraint',
	23	));
8c9d74e7	24	__PACKAGE__->meta->add_attribute('trigger' => (
	25	reader => 'trigger',
	26	predicate => 'has_trigger',
	27	));
82168dbb	28
78cd1d3b	29	sub new {
78cd1d3b	30	my ($class, $name, %options) = @_;
1d768fb1	31	$class->_process_options($name, \%options);
	32	$class->SUPER::new($name, %options);
	33	}
	34
	35	sub clone {
	36	my ($self, %options) = @_;
	37	$self->_process_options($self->name, \%options);
	38	$self->SUPER::clone(%options);
	39	}
	40
	41	sub _process_options {
	42	my ($class, $name, $options) = @_;
	43	if (exists $options->{is}) {
	44	if ($options->{is} eq 'ro') {
	45	$options->{reader} = $name;
	46	(!exists $options->{trigger})
8c9d74e7	47	\|\| confess "Cannot have a trigger on a read-only attribute";
78cd1d3b	48	}
1d768fb1	49	elsif ($options->{is} eq 'rw') {
	50	$options->{accessor} = $name;
	51	((reftype($options->{trigger}) \|\| '') eq 'CODE')
8c9d74e7	52	\|\| confess "A trigger must be a CODE reference"
1d768fb1	53	if exists $options->{trigger};
78cd1d3b	54	}
	55	}
	56
1d768fb1	57	if (exists $options->{isa}) {
02a0fb52	58
1d768fb1	59	if (exists $options->{does}) {
	60	if (eval { $options->{isa}->can('does') }) {
	61	($options->{isa}->does($options->{does}))
02a0fb52	62	\|\| confess "Cannot have an isa option and a does option if the isa does not do the does";
02a0fb52	63	}
7eaef7ad	64	else {
	65	confess "Cannot have an isa option which cannot ->does()";
	66	}
02a0fb52	67	}
02a0fb52	68
78cd1d3b	69	# allow for anon-subtypes here ...
1d768fb1	70	if (blessed($options->{isa}) && $options->{isa}->isa('Moose::Meta::TypeConstraint')) {
1d768fb1	71	$options->{type_constraint} = $options->{isa};
78cd1d3b	72	}
78cd1d3b	73	else {
c07af9d2	74
1d768fb1	75	if ($options->{isa} =~ /\\|/) {
	76	my @type_constraints = split /\s\\|\s/ => $options->{isa};
	77	$options->{type_constraint} = Moose::Util::TypeConstraints::create_type_constraint_union(
c07af9d2	78	@type_constraints
78cd1d3b	79	);
c07af9d2	80	}
	81	else {
	82	# otherwise assume it is a constraint
1d768fb1	83	my $constraint = Moose::Util::TypeConstraints::find_type_constraint($options->{isa});
c07af9d2	84	# if the constraing it not found ....
	85	unless (defined $constraint) {
	86	# assume it is a foreign class, and make
	87	# an anon constraint for it
	88	$constraint = Moose::Util::TypeConstraints::subtype(
	89	'Object',
1d768fb1	90	Moose::Util::TypeConstraints::where { $_->isa($options->{isa}) }
c07af9d2	91	);
c07af9d2	92	}
1d768fb1	93	$options->{type_constraint} = $constraint;
c07af9d2	94	}
78cd1d3b	95	}
78cd1d3b	96	}
1d768fb1	97	elsif (exists $options->{does}) {
02a0fb52	98	# allow for anon-subtypes here ...
1d768fb1	99	if (blessed($options->{does}) && $options->{does}->isa('Moose::Meta::TypeConstraint')) {
1d768fb1	100	$options->{type_constraint} = $options->{isa};
02a0fb52	101	}
	102	else {
	103	# otherwise assume it is a constraint
1d768fb1	104	my $constraint = Moose::Util::TypeConstraints::find_type_constraint($options->{does});
02a0fb52	105	# if the constraing it not found ....
	106	unless (defined $constraint) {
	107	# assume it is a foreign class, and make
	108	# an anon constraint for it
	109	$constraint = Moose::Util::TypeConstraints::subtype(
	110	'Role',
1d768fb1	111	Moose::Util::TypeConstraints::where { $_->does($options->{does}) }
02a0fb52	112	);
02a0fb52	113	}
1d768fb1	114	$options->{type_constraint} = $constraint;
02a0fb52	115	}
02a0fb52	116	}
78cd1d3b	117
1d768fb1	118	if (exists $options->{coerce} && $options->{coerce}) {
1d768fb1	119	(exists $options->{type_constraint})
4b598ea3	120	\|\| confess "You cannot have coercion without specifying a type constraint";
1d768fb1	121	(!$options->{type_constraint}->isa('Moose::Meta::TypeConstraint::Union'))
c07af9d2	122	\|\| confess "You cannot have coercion with a type constraint union";
4b598ea3	123	confess "You cannot have a weak reference to a coerced value"
1d768fb1	124	if $options->{weak_ref};
ca01a97b	125	}
78cd1d3b	126
1d768fb1	127	if (exists $options->{lazy} && $options->{lazy}) {
1d768fb1	128	(exists $options->{default})
ca01a97b	129	\|\| confess "You cannot have lazy attribute without specifying a default value for it";
1d768fb1	130	}
78cd1d3b	131	}
c0e30cf5	132
d500266f	133	sub initialize_instance_slot {
	134	my ($self, $class, $instance, $params) = @_;
	135	my $init_arg = $self->init_arg();
	136	# try to fetch the init arg from the %params ...
	137	my $val;
	138	if (exists $params->{$init_arg}) {
	139	$val = $params->{$init_arg};
	140	}
	141	else {
	142	# skip it if it's lazy
	143	return if $self->is_lazy;
	144	# and die if it's required and doesn't have a default value
	145	confess "Attribute (" . $self->name . ") is required"
	146	if $self->is_required && !$self->has_default;
	147	}
	148	# if nothing was in the %params, we can use the
	149	# attribute's default value (if it has one)
	150	if (!defined $val && $self->has_default) {
	151	$val = $self->default($instance);
	152	}
	153	if (defined $val) {
	154	if ($self->has_type_constraint) {
c07af9d2	155	my $type_constraint = $self->type_constraint;
	156	if ($self->should_coerce && $type_constraint->has_coercion) {
	157	$val = $type_constraint->coercion->coerce($val);
d500266f	158	}
c07af9d2	159	(defined($type_constraint->check($val)))
	160	\|\| confess "Attribute (" .
	161	$self->name .
	162	") does not pass the type contraint (" .
	163	$type_constraint->name .
	164	") with '$val'";
d500266f	165	}
	166	}
	167	$instance->{$self->name} = $val;
	168	if (defined $val && $self->is_weak_ref) {
	169	weaken($instance->{$self->name});
	170	}
	171	}
	172
a15dff8d	173	sub generate_accessor_method {
a15dff8d	174	my ($self, $attr_name) = @_;
ca01a97b	175	my $value_name = $self->should_coerce ? '$val' : '$_[1]';
	176	my $code = 'sub { '
	177	. 'if (scalar(@_) == 2) {'
	178	. ($self->is_required ?
	179	'defined($_[1]) \|\| confess "Attribute ($attr_name) is required, so cannot be set to undef";'
	180	: '')
	181	. ($self->should_coerce ?
	182	'my $val = $self->type_constraint->coercion->coerce($_[1]);'
	183	: '')
	184	. ($self->has_type_constraint ?
	185	('(defined $self->type_constraint->check(' . $value_name . '))'
c07af9d2	186	. '\|\| confess "Attribute ($attr_name) does not pass the type contraint (" . $self->type_constraint->name . ") with \'' . $value_name . '\'"'
ca01a97b	187	. 'if defined ' . $value_name . ';')
	188	: '')
	189	. '$_[0]->{$attr_name} = ' . $value_name . ';'
	190	. ($self->is_weak_ref ?
	191	'weaken($_[0]->{$attr_name});'
	192	: '')
8c9d74e7	193	. ($self->has_trigger ?
daea75c9	194	'$self->trigger->($_[0], ' . $value_name . ', $self);'
8c9d74e7	195	: '')
ca01a97b	196	. ' }'
	197	. ($self->is_lazy ?
	198	'$_[0]->{$attr_name} = ($self->has_default ? $self->default($_[0]) : undef)'
	199	. 'unless exists $_[0]->{$attr_name};'
	200	: '')
	201	. ' $_[0]->{$attr_name};'
	202	. ' }';
	203	my $sub = eval $code;
	204	confess "Could not create writer for '$attr_name' because $@ \n code: $code" if $@;
	205	return $sub;
a15dff8d	206	}
	207
	208	sub generate_writer_method {
	209	my ($self, $attr_name) = @_;
ca01a97b	210	my $value_name = $self->should_coerce ? '$val' : '$_[1]';
	211	my $code = 'sub { '
	212	. ($self->is_required ?
	213	'defined($_[1]) \|\| confess "Attribute ($attr_name) is required, so cannot be set to undef";'
	214	: '')
	215	. ($self->should_coerce ?
	216	'my $val = $self->type_constraint->coercion->coerce($_[1]);'
	217	: '')
	218	. ($self->has_type_constraint ?
	219	('(defined $self->type_constraint->check(' . $value_name . '))'
c07af9d2	220	. '\|\| confess "Attribute ($attr_name) does not pass the type contraint (" . $self->type_constraint->name . ") with \'' . $value_name . '\'"'
ca01a97b	221	. 'if defined ' . $value_name . ';')
	222	: '')
	223	. '$_[0]->{$attr_name} = ' . $value_name . ';'
	224	. ($self->is_weak_ref ?
	225	'weaken($_[0]->{$attr_name});'
	226	: '')
8c9d74e7	227	. ($self->has_trigger ?
daea75c9	228	'$self->trigger->($_[0], ' . $value_name . ', $self);'
8c9d74e7	229	: '')
ca01a97b	230	. ' }';
	231	my $sub = eval $code;
	232	confess "Could not create writer for '$attr_name' because $@ \n code: $code" if $@;
	233	return $sub;
a15dff8d	234	}
c0e30cf5	235
d7f17ebb	236	sub generate_reader_method {
d7f17ebb	237	my ($self, $attr_name) = @_;
ca01a97b	238	my $code = 'sub {'
	239	. 'confess "Cannot assign a value to a read-only accessor" if @_ > 1;'
	240	. ($self->is_lazy ?
	241	'$_[0]->{$attr_name} = ($self->has_default ? $self->default($_[0]) : undef)'
	242	. 'unless exists $_[0]->{$attr_name};'
	243	: '')
	244	. '$_[0]->{$attr_name};'
	245	. '}';
	246	my $sub = eval $code;
	247	confess "Could not create reader for '$attr_name' because $@ \n code: $code" if $@;
	248	return $sub;
d7f17ebb	249	}
d7f17ebb	250
c0e30cf5	251	1;
	252
	253	__END__
	254
	255	=pod
	256
	257	=head1 NAME
	258
6ba6d68c	259	Moose::Meta::Attribute - The Moose attribute metaclass
c0e30cf5	260
	261	=head1 DESCRIPTION
	262
e522431d	263	This is a subclass of L<Class::MOP::Attribute> with Moose specific
6ba6d68c	264	extensions.
	265
	266	For the most part, the only time you will ever encounter an
	267	instance of this class is if you are doing some serious deep
	268	introspection. To really understand this class, you need to refer
	269	to the L<Class::MOP::Attribute> documentation.
e522431d	270
c0e30cf5	271	=head1 METHODS
c0e30cf5	272
6ba6d68c	273	=head2 Overridden methods
	274
	275	These methods override methods in L<Class::MOP::Attribute> and add
	276	Moose specific features. You can safely assume though that they
	277	will behave just as L<Class::MOP::Attribute> does.
	278
c0e30cf5	279	=over 4
	280
	281	=item B<new>
	282
1d768fb1	283	=item B<clone>
1d768fb1	284
d500266f	285	=item B<initialize_instance_slot>
d500266f	286
a15dff8d	287	=item B<generate_accessor_method>
	288
	289	=item B<generate_writer_method>
	290
d7f17ebb	291	=item B<generate_reader_method>
d7f17ebb	292
a15dff8d	293	=back
a15dff8d	294
6ba6d68c	295	=head2 Additional Moose features
	296
	297	Moose attributes support type-contstraint checking, weak reference
	298	creation and type coercion.
	299
a15dff8d	300	=over 4
	301
	302	=item B<has_type_constraint>
	303
6ba6d68c	304	Returns true if this meta-attribute has a type constraint.
6ba6d68c	305
a15dff8d	306	=item B<type_constraint>
a15dff8d	307
6ba6d68c	308	A read-only accessor for this meta-attribute's type constraint. For
	309	more information on what you can do with this, see the documentation
	310	for L<Moose::Meta::TypeConstraint>.
a15dff8d	311
6ba6d68c	312	=item B<is_weak_ref>
a15dff8d	313
02a0fb52	314	Returns true if this meta-attribute produces a weak reference.
4b598ea3	315
ca01a97b	316	=item B<is_required>
ca01a97b	317
02a0fb52	318	Returns true if this meta-attribute is required to have a value.
ca01a97b	319
	320	=item B<is_lazy>
	321
02a0fb52	322	Returns true if this meta-attribute should be initialized lazily.
ca01a97b	323
	324	NOTE: lazy attributes, B<must> have a C<default> field set.
	325
34a66aa3	326	=item B<should_coerce>
4b598ea3	327
02a0fb52	328	Returns true if this meta-attribute should perform type coercion.
6ba6d68c	329
8c9d74e7	330	=item B<has_trigger>
8c9d74e7	331
02a0fb52	332	Returns true if this meta-attribute has a trigger set.
02a0fb52	333
8c9d74e7	334	=item B<trigger>
8c9d74e7	335
02a0fb52	336	This is a CODE reference which will be executed every time the
	337	value of an attribute is assigned. The CODE ref will get two values,
	338	the invocant and the new value. This can be used to handle I<basic>
	339	bi-directional relations.
	340
c0e30cf5	341	=back
	342
	343	=head1 BUGS
	344
	345	All complex software has bugs lurking in it, and this module is no
	346	exception. If you find a bug please either email me, or add the bug
	347	to cpan-RT.
	348
c0e30cf5	349	=head1 AUTHOR
	350
	351	Stevan Little E<lt>stevan@iinteractive.comE<gt>
	352
	353	=head1 COPYRIGHT AND LICENSE
	354
	355	Copyright 2006 by Infinity Interactive, Inc.
	356
	357	L<http://www.iinteractive.com>
	358
	359	This library is free software; you can redistribute it and/or modify
	360	it under the same terms as Perl itself.
	361
	362	=cut