[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) = @_;
	
	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";	    
	}
	
	$class->SUPER::new($name, %options);	
}

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