/usr/lib/x86_64-linux-gnu/perl5/5.34/Class/XSAccessor
Edit: /usr/lib/x86_64-linux-gnu/perl5/5.34/Class/XSAccessor/Array.pm (8931B)
package Class::XSAccessor::Array;
use 5.008;
use strict;
use warnings;
use Carp qw/croak/;
use Class::XSAccessor;
use Class::XSAccessor::Heavy;
our $VERSION = '1.19';
sub import {
my $own_class = shift;
my ($caller_pkg) = caller();
# Support both { getters => ... } and plain getters => ...
my %opts = ref($_[0]) eq 'HASH' ? %{$_[0]} : @_;
$caller_pkg = $opts{class} if defined $opts{class};
my $read_subs = $opts{getters} || {};
my $set_subs = $opts{setters} || {};
my $acc_subs = $opts{accessors} || {};
my $lvacc_subs = $opts{lvalue_accessors} || {};
my $pred_subs = $opts{predicates} || {};
my $construct_subs = $opts{constructors} || [defined($opts{constructor}) ? $opts{constructor} : ()];
my $true_subs = $opts{true} || [];
my $false_subs = $opts{false} || [];
foreach my $subtype ( ["getter", $read_subs],
["setter", $set_subs],
["accessor", $acc_subs],
["lvalue_accessor", $lvacc_subs],
["pred_subs", $pred_subs] )
{
my $subs = $subtype->[1];
foreach my $subname (keys %$subs) {
my $array_index = $subs->{$subname};
_generate_method($caller_pkg, $subname, $array_index, \%opts, $subtype->[0]);
}
}
foreach my $subtype ( ["constructor", $construct_subs],
["true", $true_subs],
["false", $false_subs] )
{
foreach my $subname (@{$subtype->[1]}) {
_generate_method($caller_pkg, $subname, "", \%opts, $subtype->[0]);
}
}
}
sub _generate_method {
my ($caller_pkg, $subname, $array_index, $opts, $type) = @_;
croak("Cannot use undef as a array index for generating an XS $type accessor. (Sub: $subname)")
if not defined $array_index;
$subname = "${caller_pkg}::$subname" if $subname !~ /::/;
Class::XSAccessor::Heavy::check_sub_existence($subname) if not $opts->{replace};
no warnings 'redefine'; # don't warn about an explicitly requested redefine
if ($type eq 'getter') {
newxs_getter($subname, $array_index);
}
if ($type eq 'lvalue_accessor') {
newxs_lvalue_accessor($subname, $array_index);
}
elsif ($type eq 'setter') {
newxs_setter($subname, $array_index, $opts->{chained}||0);
}
elsif ($type eq 'predicate') {
newxs_predicate($subname, $array_index);
}
elsif ($type eq 'constructor') {
newxs_constructor($subname);
}
elsif ($type eq 'true') {
Class::XSAccessor::newxs_boolean($subname, 1);
}
elsif ($type eq 'false') {
Class::XSAccessor::newxs_boolean($subname, 0);
}
else {
newxs_accessor($subname, $array_index, $opts->{chained}||0);
}
}
1;
__END__
=head1 NAME
Class::XSAccessor::Array - Generate fast XS accessors without runtime compilation
=head1 SYNOPSIS
package MyClassUsingArraysAsInternalStorage;
use Class::XSAccessor::Array
constructor => 'new',
getters => {
get_foo => 0, # 0 is the array index to access
get_bar => 1,
},
setters => {
set_foo => 0,
set_bar => 1,
},
accessors => { # a mutator
buz => 2,
},
predicates => { # test for definedness
has_buz => 2,
},
lvalue_accessors => { # see below
baz => 3,
},
true => [ 'is_token', 'is_whitespace' ],
false => [ 'significant' ];
# The imported methods are implemented in fast XS.
# normal class code here.
As of version 1.05, some alternative syntax forms are available:
package MyClass;
# Options can be passed as a HASH reference if you prefer it,
# which can also help PerlTidy to flow the statement correctly.
use Class::XSAccessor {
getters => {
get_foo => 0,
get_bar => 1,
},
};
=head1 DESCRIPTION
The module implements fast XS accessors both for getting at and
setting an object attribute. Additionally, the module supports
mutators and simple predicates (C
like tests for definedness
of an attributes).
The module works only with objects
that are implemented as B. Using it on hash-based objects is
bound to make your life miserable. Refer to L for
an implementation that works with hash-based objects.
A simple benchmark showed a significant performance
advantage over writing accessors in Perl.
Since version 0.10, the module can also generate simple constructors
(implemented in XS) for you. Simply supply the
C 'constructor_name'> option or the
C ['new', 'create', 'spawn']> option.
These constructors do the equivalent of the following Perl code:
sub new {
my $class = shift;
return bless [], ref($class)||$class;
}
That means they can be called on objects and classes but will not
clone objects entirely. Note that any parameters to new() will be
discarded! If there is a better idiom for array-based objects, let
me know.
While generally more obscure than hash-based objects,
objects using blessed arrays as internal representation
are a bit faster as its somewhat faster to access arrays than hashes.
Accordingly, this module is slightly faster (~10-15%) than
L, which works on hash-based objects.
The method names may be fully qualified. In the example of the
synopsis, you could have written C instead
of C. This way, you can install methods in classes other
than the current class. See also: The C option below.
Since version 1.01, you can generate extremely simple methods which
just return true or false (and always do so). If that seems like a
really superfluous thing to you, then think of a large class hierarchy
with interfaces such as PPI. This is implemented as the C
and C options, see synopsis.
=head1 OPTIONS
In addition to specifying the types and names of accessors, you can add options
which modify behaviour. The options are specified as key/value pairs just as the
accessor declaration. Example:
use Class::XSAccessor::Array
getters => {
get_foo => 0,
},
replace => 1;
The list of available options is:
=head2 replace
Set this to a true value to prevent C from
complaining about replacing existing subroutines.
=head2 chained
Set this to a true value to change the return value of setters
and mutators (when called with an argument).
If C is enabled, the setters and accessors/mutators will
return the object. Mutators called without an argument still
return the value of the associated attribute.
As with the other options, C affects all methods generated
in the same C