[p5sagit/Class-Accessor-Grouped.git] / lib / Class / Accessor / Grouped.pm

package Class::Accessor::Grouped;
use strict;
use warnings;
use Carp ();
use Class::Inspector ();
use Scalar::Util ();
use MRO::Compat;
use Sub::Name ();

our $VERSION = '0.09003';
$VERSION = eval $VERSION;

our $hasXS;

sub _hasXS {
  if (not defined $hasXS) {
    $hasXS = 0;

    eval {
      require Class::XSAccessor;
      $hasXS = 1;
    };
  }

  return $hasXS;
}

=head1 NAME

Class::Accessor::Grouped - Lets you build groups of accessors

=head1 SYNOPSIS

=head1 DESCRIPTION

This class lets you build groups of accessors that will call different
getters and setters.

=head1 METHODS

=head2 mk_group_accessors

=over 4

=item Arguments: $group, @fieldspec

Returns: none

=back

Creates a set of accessors in a given group.

$group is the name of the accessor group for the generated accessors; they
will call get_$group($field) on get and set_$group($field, $value) on set.

If you want to mimic Class::Accessor's mk_accessors $group has to be 'simple'
to tell Class::Accessor::Grouped to use its own get_simple and set_simple
methods.

@fieldspec is a list of field/accessor names; if a fieldspec is a scalar
this is used as both field and accessor name, if a listref it is expected to
be of the form [ $accessor, $field ].

=cut

sub mk_group_accessors {
  my ($self, $group, @fields) = @_;

  $self->_mk_group_accessors('make_group_accessor', $group, @fields);
  return;
}


{
    no strict 'refs';
    no warnings 'redefine';

    sub _mk_group_accessors {
        my($self, $maker, $group, @fields) = @_;
        my $class = Scalar::Util::blessed $self || $self;

        # So we don't have to do lots of lookups inside the loop.
        $maker = $self->can($maker) unless ref $maker;
        
        my $hasXS = _hasXS();

        foreach my $field (@fields) {
            if( $field eq 'DESTROY' ) {
                Carp::carp("Having a data accessor named DESTROY  in ".
                             "'$class' is unwise.");
            }

            my $name = $field;

            ($name, $field) = @$field if ref $field;
            
            my $alias = "_${name}_accessor";
            my $full_name = join('::', $class, $name);
            my $full_alias = join('::', $class, $alias);
            if ( $hasXS && $group eq 'simple' ) {
                require Class::XSAccessor;
                Class::XSAccessor->import({
                  replace => 1,
                  class => $class,
                  accessors => {
                    $name => $field,
                    $alias => $field,
                  },
                });
            }
            else {
                my $accessor = $self->$maker($group, $field);
                my $alias_accessor = $self->$maker($group, $field);
                
                *$full_name = Sub::Name::subname($full_name, $accessor);
                  #unless defined &{$class."\:\:$field"}
                
                *$full_alias = Sub::Name::subname($full_alias, $alias_accessor);
                  #unless defined &{$class."\:\:$alias"}
            }
        }
    }
}

=head2 mk_group_ro_accessors

=over 4

=item Arguments: $group, @fieldspec

Returns: none

=back

Creates a set of read only accessors in a given group. Identical to
L</mk_group_accessors> but accessors will throw an error if passed a value
rather than setting the value.

=cut

sub mk_group_ro_accessors {
    my($self, $group, @fields) = @_;

    $self->_mk_group_accessors('make_group_ro_accessor', $group, @fields);
}

=head2 mk_group_wo_accessors

=over 4

=item Arguments: $group, @fieldspec

Returns: none

=back

Creates a set of write only accessors in a given group. Identical to
L</mk_group_accessors> but accessors will throw an error if not passed a
value rather than getting the value.

=cut

sub mk_group_wo_accessors {
    my($self, $group, @fields) = @_;

    $self->_mk_group_accessors('make_group_wo_accessor', $group, @fields);
}

=head2 make_group_accessor

=over 4

=item Arguments: $group, $field

Returns: $sub (\CODE)

=back

Returns a single accessor in a given group; called by mk_group_accessors
for each entry in @fieldspec.

=cut

sub make_group_accessor {
    my ($class, $group, $field) = @_;

    my $set = "set_$group";
    my $get = "get_$group";

    # eval for faster fastiness
    my $code = eval "sub {
        if(\@_ > 1) {
            return shift->$set('$field', \@_);
        }
        else {
            return shift->$get('$field');
        }
    };";
    Carp::croak $@ if $@;

    return $code;
}

=head2 make_group_ro_accessor

=over 4

=item Arguments: $group, $field

Returns: $sub (\CODE)

=back

Returns a single read-only accessor in a given group; called by
mk_group_ro_accessors for each entry in @fieldspec.

=cut

sub make_group_ro_accessor {
    my($class, $group, $field) = @_;

    my $get = "get_$group";

    my $code = eval "sub {
        if(\@_ > 1) {
            my \$caller = caller;
            Carp::croak(\"'\$caller' cannot alter the value of '$field' on \".
                        \"objects of class '$class'\");
        }
        else {
            return shift->$get('$field');
        }
    };";
    Carp::croak $@ if $@;

    return $code;
}

=head2 make_group_wo_accessor

=over 4

=item Arguments: $group, $field

Returns: $sub (\CODE)

=back

Returns a single write-only accessor in a given group; called by
mk_group_wo_accessors for each entry in @fieldspec.

=cut

sub make_group_wo_accessor {
    my($class, $group, $field) = @_;

    my $set = "set_$group";

    my $code = eval "sub {
        unless (\@_ > 1) {
            my \$caller = caller;
            Carp::croak(\"'\$caller' cannot access the value of '$field' on \".
                        \"objects of class '$class'\");
        }
        else {
            return shift->$set('$field', \@_);
        }
    };";
    Carp::croak $@ if $@;

    return $code;
}

=head2 get_simple

=over 4

=item Arguments: $field

Returns: $value

=back

Simple getter for hash-based objects which returns the value for the field
name passed as an argument.

=cut

sub get_simple {
  return $_[0]->{$_[1]};
}

=head2 set_simple

=over 4

=item Arguments: $field, $new_value

Returns: $new_value

=back

Simple setter for hash-based objects which sets and then returns the value
for the field name passed as an argument.

=cut

sub set_simple {
  return $_[0]->{$_[1]} = $_[2];
}


=head2 get_inherited

=over 4

=item Arguments: $field

Returns: $value

=back

Simple getter for Classes and hash-based objects which returns the value for
the field name passed as an argument. This behaves much like
L<Class::Data::Accessor> where the field can be set in a base class,
inherited and changed in subclasses, and inherited and changed for object
instances.

=cut

sub get_inherited {
    my $class;

    if ( ($class = ref $_[0]) && Scalar::Util::blessed $_[0]) {
        if (Scalar::Util::reftype $_[0] eq 'HASH') {
          return $_[0]->{$_[1]} if exists $_[0]->{$_[1]};
        }
        else {
          Carp::croak('Cannot get inherited value on an object instance that is not hash-based');
        }
    }
    else {
        $class = $_[0];
    }

    no strict 'refs';
    no warnings qw/uninitialized/;

    my $cag_slot = '::__cag_'. $_[1];
    return ${$class.$cag_slot} if defined(${$class.$cag_slot});

    # we need to be smarter about recalculation, as @ISA (thus supers) can very well change in-flight
    my $cur_gen = mro::get_pkg_gen ($class);
    if ( $cur_gen != ${$class.'::__cag_pkg_gen__'} ) {
        @{$class.'::__cag_supers__'} = $_[0]->get_super_paths;
        ${$class.'::__cag_pkg_gen__'} = $cur_gen;
    }

    for (@{$class.'::__cag_supers__'}) {
        return ${$_.$cag_slot} if defined(${$_.$cag_slot});
    };

    return undef;
}

=head2 set_inherited

=over 4

=item Arguments: $field, $new_value

Returns: $new_value

=back

Simple setter for Classes and hash-based objects which sets and then returns
the value for the field name passed as an argument. When called on a hash-based
object it will set the appropriate hash key value. When called on a class, it
will set a class level variable.

B<Note:>: This method will die if you try to set an object variable on a non
hash-based object.

=cut

sub set_inherited {
    if (Scalar::Util::blessed $_[0]) {
        if (Scalar::Util::reftype $_[0] eq 'HASH') {
            return $_[0]->{$_[1]} = $_[2];
        } else {
            Carp::croak('Cannot set inherited value on an object instance that is not hash-based');
        };
    } else {
        no strict 'refs';

        return ${$_[0].'::__cag_'.$_[1]} = $_[2];
    };
}

=head2 get_component_class

=over 4

=item Arguments: $field

Returns: $value

=back

Gets the value of the specified component class.

    __PACKAGE__->mk_group_accessors('component_class' => 'result_class');

    $self->result_class->method();

    ## same as
    $self->get_component_class('result_class')->method();

=cut

sub get_component_class {
    return $_[0]->get_inherited($_[1]);
};

=head2 set_component_class

=over 4

=item Arguments: $field, $class

Returns: $new_value

=back

Inherited accessor that automatically loads the specified class before setting
it. This method will die if the specified class could not be loaded.

    __PACKAGE__->mk_group_accessors('component_class' => 'result_class');
    __PACKAGE__->result_class('MyClass');

    $self->result_class->method();

=cut

sub set_component_class {
    if ($_[2]) {
        local $^W = 0;
        if (Class::Inspector->installed($_[2]) && !Class::Inspector->loaded($_[2])) {
            eval "use $_[2]";

            Carp::croak("Could not load $_[1] '$_[2]': ", $@) if $@;
        };
    };

    return $_[0]->set_inherited($_[1], $_[2]);
};

=head2 get_super_paths

Returns a list of 'parent' or 'super' class names that the current class inherited from.

=cut

sub get_super_paths {
    return @{mro::get_linear_isa( ref($_[0]) || $_[0] )};
};

1;

=head1 PERFORMANCE

You can speed up accessors of type 'simple' by installing L<Class::XSAccessor>.

=head1 AUTHORS

Matt S. Trout <mst@shadowcatsystems.co.uk>
Christopher H. Laco <claco@chrislaco.com>

=head1 CONTRIBUTORS

groditi: Guillermo Roditi <groditi@cpan.org>
ribasushi: Peter Rabbitson <ribasushi@cpan.org>

=head1 COPYRIGHT & LICENSE

Copyright (c) 2006-2010 Matt S. Trout <mst@shadowcatsystems.co.uk>

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

=cut
Commit	Line	Data
963a69a5	1	package Class::Accessor::Grouped;
	2	use strict;
	3	use warnings;
a0bce8bc	4	use Carp ();
331e820d	5	use Class::Inspector ();
a0bce8bc	6	use Scalar::Util ();
8787799c	7	use MRO::Compat;
1ee74bdd	8	use Sub::Name ();
331e820d	9
af169484	10	our $VERSION = '0.09003';
15cf8e32	11	$VERSION = eval $VERSION;
963a69a5	12
a2537c55	13	our $hasXS;
af169484	14
a2537c55	15	sub _hasXS {
a2537c55	16	if (not defined $hasXS) {
	17	$hasXS = 0;
	18
8ef9b3ff	19	eval {
	20	require Class::XSAccessor;
	21	$hasXS = 1;
	22	};
a2537c55	23	}
	24
	25	return $hasXS;
	26	}
	27
963a69a5	28	=head1 NAME
963a69a5	29
1ad8d8c6	30	Class::Accessor::Grouped - Lets you build groups of accessors
963a69a5	31
	32	=head1 SYNOPSIS
	33
	34	=head1 DESCRIPTION
	35
	36	This class lets you build groups of accessors that will call different
	37	getters and setters.
	38
	39	=head1 METHODS
	40
	41	=head2 mk_group_accessors
	42
	43	=over 4
	44
	45	=item Arguments: $group, @fieldspec
	46
	47	Returns: none
	48
	49	=back
	50
	51	Creates a set of accessors in a given group.
	52
	53	$group is the name of the accessor group for the generated accessors; they
	54	will call get_$group($field) on get and set_$group($field, $value) on set.
	55
22fa6720	56	If you want to mimic Class::Accessor's mk_accessors $group has to be 'simple'
	57	to tell Class::Accessor::Grouped to use its own get_simple and set_simple
	58	methods.
	59
963a69a5	60	@fieldspec is a list of field/accessor names; if a fieldspec is a scalar
	61	this is used as both field and accessor name, if a listref it is expected to
	62	be of the form [ $accessor, $field ].
	63
	64	=cut
	65
	66	sub mk_group_accessors {
	67	my ($self, $group, @fields) = @_;
	68
	69	$self->_mk_group_accessors('make_group_accessor', $group, @fields);
	70	return;
	71	}
	72
	73
	74	{
	75	no strict 'refs';
	76	no warnings 'redefine';
	77
	78	sub _mk_group_accessors {
	79	my($self, $maker, $group, @fields) = @_;
a0bce8bc	80	my $class = Scalar::Util::blessed $self \|\| $self;
963a69a5	81
	82	# So we don't have to do lots of lookups inside the loop.
	83	$maker = $self->can($maker) unless ref $maker;
9540f4e4	84
9540f4e4	85	my $hasXS = _hasXS();
963a69a5	86
	87	foreach my $field (@fields) {
	88	if( $field eq 'DESTROY' ) {
a0bce8bc	89	Carp::carp("Having a data accessor named DESTROY in ".
963a69a5	90	"'$class' is unwise.");
	91	}
	92
	93	my $name = $field;
	94
	95	($name, $field) = @$field if ref $field;
9540f4e4	96
963a69a5	97	my $alias = "_${name}_accessor";
1ee74bdd	98	my $full_name = join('::', $class, $name);
1ee74bdd	99	my $full_alias = join('::', $class, $alias);
9540f4e4	100	if ( $hasXS && $group eq 'simple' ) {
46f1ef81	101	require Class::XSAccessor;
96bd9337	102	Class::XSAccessor->import({
	103	replace => 1,
	104	class => $class,
	105	accessors => {
	106	$name => $field,
	107	$alias => $field,
	108	},
	109	});
9540f4e4	110	}
	111	else {
	112	my $accessor = $self->$maker($group, $field);
	113	my $alias_accessor = $self->$maker($group, $field);
	114
	115	*$full_name = Sub::Name::subname($full_name, $accessor);
	116	#unless defined &{$class."\:\:$field"}
	117
	118	*$full_alias = Sub::Name::subname($full_alias, $alias_accessor);
	119	#unless defined &{$class."\:\:$alias"}
	120	}
963a69a5	121	}
	122	}
	123	}
	124
	125	=head2 mk_group_ro_accessors
	126
	127	=over 4
	128
	129	=item Arguments: $group, @fieldspec
	130
	131	Returns: none
	132
	133	=back
	134
	135	Creates a set of read only accessors in a given group. Identical to
a557f8ad	136	L</mk_group_accessors> but accessors will throw an error if passed a value
963a69a5	137	rather than setting the value.
	138
	139	=cut
	140
	141	sub mk_group_ro_accessors {
	142	my($self, $group, @fields) = @_;
	143
	144	$self->_mk_group_accessors('make_group_ro_accessor', $group, @fields);
	145	}
	146
	147	=head2 mk_group_wo_accessors
	148
	149	=over 4
	150
	151	=item Arguments: $group, @fieldspec
	152
	153	Returns: none
	154
	155	=back
	156
	157	Creates a set of write only accessors in a given group. Identical to
a557f8ad	158	L</mk_group_accessors> but accessors will throw an error if not passed a
963a69a5	159	value rather than getting the value.
	160
	161	=cut
	162
	163	sub mk_group_wo_accessors {
	164	my($self, $group, @fields) = @_;
	165
	166	$self->_mk_group_accessors('make_group_wo_accessor', $group, @fields);
	167	}
	168
	169	=head2 make_group_accessor
	170
	171	=over 4
	172
	173	=item Arguments: $group, $field
	174
	175	Returns: $sub (\CODE)
	176
	177	=back
	178
	179	Returns a single accessor in a given group; called by mk_group_accessors
	180	for each entry in @fieldspec.
	181
	182	=cut
	183
	184	sub make_group_accessor {
	185	my ($class, $group, $field) = @_;
	186
	187	my $set = "set_$group";
	188	my $get = "get_$group";
	189
a0bce8bc	190	# eval for faster fastiness
43db6fd3	191	my $code = eval "sub {
a0bce8bc	192	if(\@_ > 1) {
a0bce8bc	193	return shift->$set('$field', \@_);
963a69a5	194	}
963a69a5	195	else {
a0bce8bc	196	return shift->$get('$field');
963a69a5	197	}
43db6fd3	198	};";
	199	Carp::croak $@ if $@;
	200
	201	return $code;
963a69a5	202	}
	203
	204	=head2 make_group_ro_accessor
	205
	206	=over 4
	207
	208	=item Arguments: $group, $field
	209
	210	Returns: $sub (\CODE)
	211
	212	=back
	213
	214	Returns a single read-only accessor in a given group; called by
	215	mk_group_ro_accessors for each entry in @fieldspec.
	216
	217	=cut
	218
	219	sub make_group_ro_accessor {
	220	my($class, $group, $field) = @_;
	221
	222	my $get = "get_$group";
	223
43db6fd3	224	my $code = eval "sub {
a0bce8bc	225	if(\@_ > 1) {
	226	my \$caller = caller;
	227	Carp::croak(\"'\$caller' cannot alter the value of '$field' on \".
	228	\"objects of class '$class'\");
963a69a5	229	}
963a69a5	230	else {
a0bce8bc	231	return shift->$get('$field');
963a69a5	232	}
43db6fd3	233	};";
	234	Carp::croak $@ if $@;
	235
	236	return $code;
963a69a5	237	}
	238
	239	=head2 make_group_wo_accessor
	240
	241	=over 4
	242
	243	=item Arguments: $group, $field
	244
	245	Returns: $sub (\CODE)
	246
	247	=back
	248
	249	Returns a single write-only accessor in a given group; called by
	250	mk_group_wo_accessors for each entry in @fieldspec.
	251
	252	=cut
	253
	254	sub make_group_wo_accessor {
	255	my($class, $group, $field) = @_;
	256
	257	my $set = "set_$group";
	258
43db6fd3	259	my $code = eval "sub {
a0bce8bc	260	unless (\@_ > 1) {
	261	my \$caller = caller;
	262	Carp::croak(\"'\$caller' cannot access the value of '$field' on \".
	263	\"objects of class '$class'\");
963a69a5	264	}
963a69a5	265	else {
a0bce8bc	266	return shift->$set('$field', \@_);
963a69a5	267	}
43db6fd3	268	};";
	269	Carp::croak $@ if $@;
	270
	271	return $code;
963a69a5	272	}
	273
	274	=head2 get_simple
	275
	276	=over 4
	277
	278	=item Arguments: $field
	279
	280	Returns: $value
	281
	282	=back
	283
	284	Simple getter for hash-based objects which returns the value for the field
	285	name passed as an argument.
	286
	287	=cut
	288
	289	sub get_simple {
a0bce8bc	290	return $_[0]->{$_[1]};
963a69a5	291	}
	292
	293	=head2 set_simple
	294
	295	=over 4
	296
	297	=item Arguments: $field, $new_value
	298
	299	Returns: $new_value
	300
	301	=back
	302
	303	Simple setter for hash-based objects which sets and then returns the value
	304	for the field name passed as an argument.
	305
	306	=cut
	307
	308	sub set_simple {
a0bce8bc	309	return $_[0]->{$_[1]} = $_[2];
963a69a5	310	}
963a69a5	311
e6f2a0fd	312
	313	=head2 get_inherited
	314
	315	=over 4
	316
	317	=item Arguments: $field
	318
	319	Returns: $value
	320
	321	=back
	322
331e820d	323	Simple getter for Classes and hash-based objects which returns the value for
	324	the field name passed as an argument. This behaves much like
	325	L<Class::Data::Accessor> where the field can be set in a base class,
	326	inherited and changed in subclasses, and inherited and changed for object
	327	instances.
e6f2a0fd	328
	329	=cut
	330
	331	sub get_inherited {
a49c32d9	332	my $class;
e6f2a0fd	333
62cf9924	334	if ( ($class = ref $_[0]) && Scalar::Util::blessed $_[0]) {
	335	if (Scalar::Util::reftype $_[0] eq 'HASH') {
	336	return $_[0]->{$_[1]} if exists $_[0]->{$_[1]};
	337	}
	338	else {
	339	Carp::croak('Cannot get inherited value on an object instance that is not hash-based');
	340	}
	341	}
	342	else {
a0bce8bc	343	$class = $_[0];
62cf9924	344	}
e6f2a0fd	345
e6f2a0fd	346	no strict 'refs';
fe63d727	347	no warnings qw/uninitialized/;
62cf9924	348
	349	my $cag_slot = '::__cag_'. $_[1];
	350	return ${$class.$cag_slot} if defined(${$class.$cag_slot});
e6f2a0fd	351
4f8ce9da	352	# we need to be smarter about recalculation, as @ISA (thus supers) can very well change in-flight
62cf9924	353	my $cur_gen = mro::get_pkg_gen ($class);
	354	if ( $cur_gen != ${$class.'::__cag_pkg_gen__'} ) {
	355	@{$class.'::__cag_supers__'} = $_[0]->get_super_paths;
	356	${$class.'::__cag_pkg_gen__'} = $cur_gen;
	357	}
a49c32d9	358
62cf9924	359	for (@{$class.'::__cag_supers__'}) {
62cf9924	360	return ${$_.$cag_slot} if defined(${$_.$cag_slot});
e6f2a0fd	361	};
c46050d3	362
9c3d5179	363	return undef;
e6f2a0fd	364	}
	365
	366	=head2 set_inherited
	367
	368	=over 4
	369
	370	=item Arguments: $field, $new_value
	371
	372	Returns: $new_value
	373
	374	=back
	375
331e820d	376	Simple setter for Classes and hash-based objects which sets and then returns
	377	the value for the field name passed as an argument. When called on a hash-based
	378	object it will set the appropriate hash key value. When called on a class, it
	379	will set a class level variable.
e6f2a0fd	380
331e820d	381	B<Note:>: This method will die if you try to set an object variable on a non
331e820d	382	hash-based object.
e6f2a0fd	383
	384	=cut
	385
	386	sub set_inherited {
a0bce8bc	387	if (Scalar::Util::blessed $_[0]) {
	388	if (Scalar::Util::reftype $_[0] eq 'HASH') {
	389	return $_[0]->{$_[1]} = $_[2];
e6f2a0fd	390	} else {
a0bce8bc	391	Carp::croak('Cannot set inherited value on an object instance that is not hash-based');
e6f2a0fd	392	};
	393	} else {
	394	no strict 'refs';
	395
a0bce8bc	396	return ${$_[0].'::__cag_'.$_[1]} = $_[2];
e6f2a0fd	397	};
	398	}
	399
331e820d	400	=head2 get_component_class
	401
	402	=over 4
	403
	404	=item Arguments: $field
	405
	406	Returns: $value
	407
	408	=back
	409
	410	Gets the value of the specified component class.
	411
	412	__PACKAGE__->mk_group_accessors('component_class' => 'result_class');
97d76fb4	413
331e820d	414	$self->result_class->method();
97d76fb4	415
331e820d	416	## same as
	417	$self->get_component_class('result_class')->method();
	418
	419	=cut
	420
	421	sub get_component_class {
a0bce8bc	422	return $_[0]->get_inherited($_[1]);
331e820d	423	};
	424
	425	=head2 set_component_class
	426
	427	=over 4
	428
	429	=item Arguments: $field, $class
	430
	431	Returns: $new_value
	432
	433	=back
	434
	435	Inherited accessor that automatically loads the specified class before setting
	436	it. This method will die if the specified class could not be loaded.
	437
	438	__PACKAGE__->mk_group_accessors('component_class' => 'result_class');
	439	__PACKAGE__->result_class('MyClass');
97d76fb4	440
331e820d	441	$self->result_class->method();
	442
	443	=cut
	444
	445	sub set_component_class {
a0bce8bc	446	if ($_[2]) {
bce7bdf8	447	local $^W = 0;
a0bce8bc	448	if (Class::Inspector->installed($_[2]) && !Class::Inspector->loaded($_[2])) {
a0bce8bc	449	eval "use $_[2]";
331e820d	450
a0bce8bc	451	Carp::croak("Could not load $_[1] '$_[2]': ", $@) if $@;
331e820d	452	};
	453	};
	454
a0bce8bc	455	return $_[0]->set_inherited($_[1], $_[2]);
331e820d	456	};
331e820d	457
a49c32d9	458	=head2 get_super_paths
	459
	460	Returns a list of 'parent' or 'super' class names that the current class inherited from.
	461
	462	=cut
	463
	464	sub get_super_paths {
62cf9924	465	return @{mro::get_linear_isa( ref($_[0]) \|\| $_[0] )};
a49c32d9	466	};
a49c32d9	467
a2537c55	468	1;
b9a69571	469
9d7d52da	470	=head1 PERFORMANCE
15cf8e32	471
a2537c55	472	You can speed up accessors of type 'simple' by installing L<Class::XSAccessor>.
963a69a5	473
	474	=head1 AUTHORS
	475
	476	Matt S. Trout <mst@shadowcatsystems.co.uk>
97972dcb	477	Christopher H. Laco <claco@chrislaco.com>
963a69a5	478
8ef9b3ff	479	=head1 CONTRIBUTORS
dfb86526	480
8ef9b3ff	481	groditi: Guillermo Roditi <groditi@cpan.org>
8ef9b3ff	482	ribasushi: Peter Rabbitson <ribasushi@cpan.org>
dfb86526	483
4fe25633	484	=head1 COPYRIGHT & LICENSE
963a69a5	485
af169484	486	Copyright (c) 2006-2010 Matt S. Trout <mst@shadowcatsystems.co.uk>
963a69a5	487
4fe25633	488	This program is free software; you can redistribute it and/or modify
4fe25633	489	it under the same terms as perl itself.
963a69a5	490
4fe25633	491	=cut