Class::constr - Pragma to implement constructor methods
Included in OOTools 1.76 distribution.
The latest versions changes are reported in the Changes file in this distribution.
The distribution includes:
Class::constr
Pragma to implement constructor methods
Class::props
Pragma to implement lvalue accessors with options
Class::groups
Pragma to implement groups of properties accessors with options
Object::props
Object::groups
Perl version >= 5.6.1
perl -MCPAN -e 'install OOTools'
From the directory where this file is located, type:
perl Makefile.PL make make test make install
package MyClass ; # implement constructor without options use Class::constr ; # with options use Class::constr { name => 'new_object' , pre_process => \&change_input init => [ qw( init1 init2 ) ] , no_strict => 1 } ; # init1 and init2 will be called at run-time
# creates a new object and eventually validates # the properties if any validation property option is set my $object = MyClass->new(digits => '123');
This pragma easily implements constructor methods for your class. Use it with Class::props and Object::props to automatically validate the input passed with new(), or use the no_strict option to accept unknown properties as well.
new()
no_strict
You can completely avoid to write the constructor by just using it and eventually declaring the name and the init methods to call.
IMPORTANT NOTE: If you write any script that rely on this module, you better send me an e-mail so I will inform you in advance about eventual planned changes, new releases, and other relevant issues that could speed-up your work.
If you want to see some working example of this module, take a look at the source of my other distributions.
The name of the constructor method. If you omit this option the 'new' name will be used by default.
With no_strict option set to a true value, the constructor method accepts and sets also unknown properties (i.e. not predeclared). You have to access the unknown properties without any accessor method. All the other options will work as expected. Without this option the constructor will croak if any property does not have an accessor method.
You can set a code reference to preprocess @_.
The original @_ is passed to the referenced pre_process CODE. Modify @_ in the CODE to change the actual input value.
@_
# This code will transform the @_ on input # if it's passed a ref to an ARRAY # [ qw|a b c| ] will become # ( a=>'a', b=>'b', c=>'c') use Class::constr { name => 'new' , pre_process=> sub { if ( ref $_[1] eq 'ARRAY' ) { $_[1] = { map { $_=>$_ } @{$_[1]} } } } }
Use this option if you want to call other methods in your class to further initialize the object. You can group methods by passing a reference to an array containing the method names.
After the assignation and validation of the properties, the initialization methods in the init option will be called. Each init method will receive the blessed object passed in $_[0] and the other parameters in the remaining @_.
init
$_[0]
Any init method can cancel construction of the object by undefining $_[0]. This will cause the constructor to return undef. If you prefer, you can explicitly croak from your init method.
croak
use Class::constr { name => 'new' , init => 'too_many' } ; sub too_many { if ( $MyClass::num_instances > $MyClass::max_instances) { $_[0] = undef # Do not allow new object to be returned } else { $MyClass::num_instances++ } }
If this option is set to a true value, the constructor will be a "copy constructor". Copy constructors allow you to create a new object that inherits data from an existing object. Values passed to the constructor will overwrite copied values, and init methods will also have a chance to manipulate the values.
Warning: The copy constructor will only perform a shallow copy, which means that after a copy any references stored in properties will point to the same variable in both objects (the objects will share a single variable instead of each having its own private copy). If you don't want this behavior, you should reset these properties in your init method. Properties created by the Object::groups pragma are effected by this. Such properties should be explicitly set to undef in your init method for sane behavior.
undef
Copy constructors may also be called as traditional class method constructors, but of course there will be no values to be copied into the new object. Generally, you will want to have a normal constructor to use when you don't need the copy functionality.
package My::Class; use Class::constr ( { name => 'new' , init => '_init' } , { name => 'copy_me' , copy => 1 , init => '_init_copy' # Special init undefs properties # containing shared references } ) # Then in your program somewhere my $obj = My::Class->new( property => 1); my $copy = $obj->copy_me(); # $copy->property == 1
If you need support or if you want just to send me some feedback or request, please use this link: http://perl.4pro.net/?Class::constr.
© 2004 by Domizio Demichelis.
All Rights Reserved. This module is free software. It may be used, redistributed and/or modified under the same terms as perl itself.
Thanks to Juerd Waalboer (http://search.cpan.org/author/JUERD) that with its Attribute::Property inspired the creation of this distribution.
Thanks to Vince Veselosky ("/search.cpan.org/author/VESELOSKY)" in (http:) for his patches and improvement.
1 POD Error
The following errors were encountered while parsing the POD:
Non-ASCII character seen before =encoding in '©'. Assuming CP1252
To install Class::props, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Class::props
CPAN shell
perl -MCPAN -e shell install Class::props
For more information on module installation, please visit the detailed CPAN module installation guide.