SEARCH
NEW RPMS
DIRECTORIES
ABOUT
FAQ
VARIOUS
BLOG
DONATE


YUM REPOSITORY

 
 

MAN page from CentOS 6 psrk-perl-Object-Accessor-0.36-27.5.noarch.rpm

Object::Accessor

Section: Perl Programmers Reference Guide (3pm)
Updated: 2011-06-07
Index 

NAME

Object::Accessor - interface to create per object accessors 

SYNOPSIS

    ### using the object    $obj = Object::Accessor->new;        # create object    $obj = Object::Accessor->new(@list); # create object with accessors    $obj = Object::Accessor->new(\%h);   # create object with accessors                                         # and their allow handlers    $bool   = $obj->mk_accessors('foo'); # create accessors    $bool   = $obj->mk_accessors(        # create accessors with input               {foo => ALLOW_HANDLER} ); # validation    $bool   = $obj->mk_aliases(          # create an alias to an existing                alias_name => 'method'); # method name                    $clone  = $obj->mk_clone;            # create a clone of original                                         # object without data    $bool   = $obj->mk_flush;            # clean out all data    @list   = $obj->ls_accessors;        # retrieves a list of all                                         # accessors for this object    $bar    = $obj->foo('bar');          # set 'foo' to 'bar'    $bar    = $obj->foo();               # retrieve 'bar' again    $sub    = $obj->can('foo');          # retrieve coderef for                                         # 'foo' accessor    $bar    = $sub->('bar');             # set 'foo' via coderef    $bar    = $sub->();                  # retrieve 'bar' by coderef    ### using the object as base class    package My::Class;    use base 'Object::Accessor';    $obj    = My::Class->new;               # create base object    $bool   = $obj->mk_accessors('foo');    # create accessors, etc...    ### make all attempted access to non-existant accessors fatal    ### (defaults to false)    $Object::Accessor::FATAL = 1;    ### enable debugging    $Object::Accessor::DEBUG = 1;    ### advanced usage -- callbacks    {   my $obj = Object::Accessor->new('foo');        $obj->register_callback( sub { ... } );                $obj->foo( 1 ); # these calls invoke the callback you registered        $obj->foo()     # which allows you to change the get/set                         # behaviour and what is returned to the caller.    }            ### advanced usage -- lvalue attributes    {   my $obj = Object::Accessor::Lvalue->new('foo');        print $obj->foo = 1;            # will print 1    }    ### advanced usage -- scoped attribute values    {   my $obj = Object::Accessor->new('foo');                $obj->foo( 1 );        print $obj->foo;                # will print 1        ### bind the scope of the value of attribute 'foo'        ### to the scope of '$x' -- when $x goes out of         ### scope, 'foo's previous value will be restored        {   $obj->foo( 2 => \my $x );            print $obj->foo, ' ', $x;   # will print '2 2'        }        print $obj->foo;                # will print 1    }
 

DESCRIPTION

"Object::Accessor" provides an interface to create per objectaccessors (as opposed to per "Class" accessors, as, for example,"Class::Accessor" provides).

You can choose to either subclass this module, and thus using itsaccessors on your own module, or to store an "Object::Accessor"object inside your own object, and access the accessors from there.See the "SYNOPSIS" for examples. 

METHODS

 

$object = Object::Accessor->new( [ARGS] );

Creates a new (and empty) "Object::Accessor" object. This method isinheritable.

Any arguments given to "new" are passed straight to "mk_accessors".

If you want to be able to assign to your accessors as if theywere "lvalue"s, you should create your object in the "Object::Acccessor::Lvalue" namespace instead. See the sectionon "LVALUE ACCESSORS" below. 

$bool = $object->mk_accessors( @ACCESSORS | \%ACCESSOR_MAP );

Creates a list of accessors for this object (and "NOT" for other onesin the same class!).Will not clobber existing data, so if an accessor already exists,requesting to create again is effectively a "no-op".

When providing a "hashref" as argument, rather than a normal list,you can specify a list of key/value pairs of accessors and theirrespective input validators. The validators can be anything that"Params::Check"'s "allow" function accepts. Please see its manpagefor details.

For example:

    $object->mk_accessors( {        foo     => qr/^\d+$/,       # digits only        bar     => [0,1],           # booleans        zot     => \&my_sub         # a custom verification sub    } );

Returns true on success, false on failure.

Accessors that are called on an object, that do not exist return"undef" by default, but you can make this a fatal error by setting theglobal variable $FATAL to true. See the section on "GLOBALVARIABLES" for details.

Note that you can bind the values of attributes to a scope. This allowsyou to "temporarily" change a value of an attribute, and have it's original value restored up on the end of it's bound variable's scope;

For example, in this snippet of code, the attribute "foo" will temporarily be set to 2, until the end of the scope of $x, at which point the original value of 1 will be restored.

    my $obj = Object::Accessor->new;        $obj->mk_accessors('foo');    $obj->foo( 1 );    print $obj->foo;                # will print 1    ### bind the scope of the value of attribute 'foo'    ### to the scope of '$x' -- when $x goes out of     ### scope, 'foo' previous value will be restored    {   $obj->foo( 2 => \my $x );        print $obj->foo, ' ', $x;   # will print '2 2'    }    print $obj->foo;                # will print 1

Note that all accessors are read/write for everyone. See the "TODO"section for details. 

@list = $self->ls_accessors;

Returns a list of accessors that are supported by the current object.The corresponding coderefs can be retrieved by passing this list oneby one to the "can" method. 

$ref = $self->ls_allow(KEY)

Returns the allow handler for the given key, which can be used with"Params::Check"'s "allow()" handler. If there was no allow handlerspecified, an allow handler that always returns true will be returned. 

$bool = $self->mk_aliases( alias => method, [alias2 => method2, ...] );

Creates an alias for a given method name. For all intents and purposes,these two accessors are now identical for this object. This is akin todoing the following on the symbol table level:

  *alias = *method

This allows you to do the following:

  $self->mk_accessors('foo');  $self->mk_aliases( bar => 'foo' );    $self->bar( 42 );  print $self->foo;     # will print 42
 

$clone = $self->mk_clone;

Makes a clone of the current object, which will have the exact sameaccessors as the current object, but without the data stored in them. 

$bool = $self->mk_flush;

Flushes all the data from the current object; all accessors will beset back to their default state of "undef".

Returns true on success and false on failure. 

$bool = $self->mk_verify;

Checks if all values in the current object are in accordance with theirown allow handler. Specifically useful to check if an empty initialisedobject has been filled with values satisfying their own allow criteria. 

$bool = $self->register_callback( sub { ... } );

This method allows you to register a callback, that is invokedevery time an accessor is called. This allows you to munge inputdata, access external data stores, etc.

You are free to return whatever you wish. On a "set" call, thedata is even stored in the object.

Below is an example of the use of a callback.

    $object->some_method( "some_value" );        my $callback = sub {        my $self    = shift; # the object        my $meth    = shift; # "some_method"        my $val     = shift; # ["some_value"]                               # could be undef -- check 'exists';                             # if scalar @$val is empty, it was a 'get'            # your code here        return $new_val;     # the value you want to be set/returned    }

To access the values stored in the object, circumventing thecallback structure, you should use the "___get" and "___set" methodsdocumented further down. 

$bool = $self->can( METHOD_NAME )

This method overrides "UNIVERAL::can" in order to provide coderefs toaccessors which are loaded on demand. It will behave just like"UNIVERSAL::can" where it can --- returning a class method if it exists,or a closure pointing to a valid accessor of this particular object.

You can use it as follows:

    $sub = $object->can('some_accessor');   # retrieve the coderef    $sub->('foo');                          # 'some_accessor' now set                                            # to 'foo' for $object    $foo = $sub->();                        # retrieve the contents                                            # of 'some_accessor'

See the "SYNOPSIS" for more examples. 

$val = $self->___get( METHOD_NAME );

Method to directly access the value of the given accessor in theobject. It circumvents all calls to allow checks, callbakcs, etc.

Use only if you "Know What You Are Doing"! General usage for this functionality would be in your own custom callbacks. 

$bool = $self->___set( METHOD_NAME => VALUE );

Method to directly set the value of the given accessor in theobject. It circumvents all calls to allow checks, callbakcs, etc.

Use only if you "Know What You Are Doing"! General usage for this functionality would be in your own custom callbacks. 

$bool = $self->___alias( ALIAS => METHOD );

Method to directly alias one accessor to another forthis object. It circumvents all sanity checks, etc.

Use only if you "Know What You Are Doing"! 

LVALUE ACCESSORS

"Object::Accessor" supports "lvalue" attributes as well. To enablethese, you should create your objects in the designated namespace,"Object::Accessor::Lvalue". For example:

    my $obj = Object::Accessor::Lvalue->new('foo');    $obj->foo += 1;    print $obj->foo;

will actually print 1 and work as expected. Since this is anoptional feature, that's not desirable in all cases, we requireyou to explicitly use the "Object::Accessor::Lvalue" class.

Doing the same on the standard "Object">Accessor> class wouldgenerate the following code & errors:

    my $obj = Object::Accessor->new('foo');    $obj->foo += 1;    Can't modify non-lvalue subroutine call

Note that "lvalue" support on "AUTOLOAD" routines is a"perl 5.8.x" feature. See perldoc perl58delta for details. 

CAVEATS

*
Allow handlers

Due to the nature of "lvalue subs", we never get access to thevalue you are assigning, so we can not check it againt your allowhandler. Allow handlers are therefor unsupported under "lvalue"conditions.

See "perldoc perlsub" for details.

*
Callbacks

Due to the nature of "lvalue subs", we never get access to thevalue you are assigning, so we can not check provide this valueto your callback. Furthermore, we can not distinguish betweena "get" and a "set" call. Callbacks are therefor unsupported under "lvalue" conditions.

See "perldoc perlsub" for details.

 

GLOBAL VARIABLES

 

$Object::Accessor::FATAL

Set this variable to true to make all attempted access to non-existantaccessors be fatal.This defaults to "false". 

$Object::Accessor::DEBUG

Set this variable to enable debugging output.This defaults to "false". 

TODO

 

Create read-only accessors

Currently all accessors are read/write for everyone. Perhaps a futurerelease should make it possible to have read-only accessors as well. 

CAVEATS

If you use codereferences for your allow handlers, you will not be ableto freeze the data structures using "Storable".

Due to a bug in storable (until at least version 2.15), "qr//" compiled regexes also don't de-serialize properly. Although this bug has been reported, you should be aware of this issue when serializing your objects.

You can track the bug here:

    http://rt.cpan.org/Ticket/Display.html?id=1827
 

BUG REPORTS

Please report bugs or other issues to <bug-object-accessorAATTrt.cpan.org>. 

AUTHOR

This module by Jos Boumans <kaneAATTcpan.org>. 

COPYRIGHT

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


 

Index

NAME
SYNOPSIS
DESCRIPTION
METHODS
$object = Object::Accessor->new( [ARGS] );
$bool = $object->mk_accessors( @ACCESSORS | \%ACCESSOR_MAP );
@list = $self->ls_accessors;
$ref = $self->ls_allow(KEY)
$bool = $self->mk_aliases( alias => method, [alias2 => method2, ...] );
$clone = $self->mk_clone;
$bool = $self->mk_flush;
$bool = $self->mk_verify;
$bool = $self->register_callback( sub { ... } );
$bool = $self->can( METHOD_NAME )
$val = $self->___get( METHOD_NAME );
$bool = $self->___set( METHOD_NAME => VALUE );
$bool = $self->___alias( ALIAS => METHOD );
LVALUE ACCESSORS
CAVEATS
GLOBAL VARIABLES
$Object::Accessor::FATAL
$Object::Accessor::DEBUG
TODO
Create read-only accessors
CAVEATS
BUG REPORTS
AUTHOR
COPYRIGHT

This document was created byman2html,using the manual pages.