MakeMethods::Standard:UservContributed PerlMakeMethods::Standard::Universal(3)NAMEClass::MakeMethods::Standard::Universal - Generic Methods
SYNOPSIS
package MyObject;
use Class::MakeMethods::Standard::Universal (
no_op => 'this',
abstract => 'that',
delegate => { name=>'play_music', target=>'instrument', method=>'play' },
);
DESCRIPTION
The Standard::Universal suclass of MakeMethods provides a [INCOMPLETE].
Calling Conventions
When you "use" this package, the method names you provide as arguments
cause subroutines to be generated and installed in your module.
See "Calling Conventions" in Class::MakeMethods::Standard for more
information.
Declaration Syntax
To declare methods, pass in pairs of a method-type name followed by one
or more method names.
Valid method-type names for this package are listed in "METHOD
GENERATOR TYPES".
See "Declaration Syntax" in Class::MakeMethods::Standard and "Parameter
Syntax" in Class::MakeMethods::Standard for more information.
METHOD GENERATOR TYPES
no_op - Placeholder
For each method name passed, returns a subroutine with the following
characteristics:
· Does nothing.
You might want to create and use such methods to provide hooks for
subclass activity.
Sample declaration and usage:
package MyObject;
use Class::MakeMethods::Standard::Universal (
no_op => 'whatever',
);
...
# Doesn't do anything
MyObject->whatever();
abstract - Placeholder
For each method name passed, returns a subroutine with the following
characteristics:
· Fails with an error message.
This is intended to support the use of abstract methods, that must be
overidden in a useful subclass.
If each subclass is expected to provide an implementation of a given
method, using this abstract method will replace the generic error
message below with the clearer, more explicit error message that
follows it:
Can't locate object method "foo" via package "My::Subclass"
The "foo" method is abstract and can not be called on My::Subclass
However, note that the existence of this method will be detected by
UNIVERSAL::can(), so it is not suitable for use in optional interfaces,
for which you may wish to be able to detect whether the method is
supported or not.
Sample declaration and usage:
package MyObject;
use Class::MakeMethods::Standard::Universal (
abstract => 'whatever',
);
...
package MySubclass;
sub whatever { ... }
# Failure
MyObject->whatever();
# Success
MySubclass->whatever();
call_methods - Call methods by name
For each method name passed, returns a subroutine with the following
characteristics:
· Accepts a hash of key-value pairs, or a reference to hash of such
pairs. For each pair, the key is interpreted as the name of a
method to call, and the value is the argument to be passed to that
method.
Sample declaration and usage:
package MyObject;
use Class::MakeMethods::Standard::Universal (
call_methods => 'init',
);
...
my $object = MyObject->new()
$object->init( foo => 'Foozle', bar => 'Barbados' );
# Equivalent to:
$object->foo('Foozle');
$object->bar('Barbados');
join_methods - Concatenate results of other methods
For each method name passed, returns a subroutine with the following
characteristics:
· Has a list of other methods names as an arrayref in the 'methods'
parameter. Required.
· When called, calls each of the named method on itself, in order,
and returns the concatenation of their results.
· If a 'join' parameter is provided it is included between each
method result.
· If the 'skip_blanks' parameter is omitted, or is provided with a
true value, removes all undefined or empty-string values from the
results.
alias - Call another method
For each method name passed, returns a subroutine with the following
characteristics:
· Calls another method on the same callee.
You might create such a method to extend or adapt your class'
interface.
Sample declaration and usage:
package MyObject;
use Class::MakeMethods::Standard::Universal (
alias => { name=>'click_here', target=>'complex_machinery' }
);
sub complex_machinery { ... }
...
$myobj->click_here(...); # calls $myobj->complex_machinery(...)
delegate - Use another object to provide method
For each method name passed, returns a subroutine with the following
characteristics:
· Calls a method on self to retrieve another object, and then calls a
method on that object and returns its value.
You might want to create and use such methods to faciliate composition
of objects from smaller objects.
Sample declaration and usage:
package MyObject;
use Class::MakeMethods::Standard::Universal (
'Standard::Hash:object' => { name=>'instrument' },
delegate => { name=>'play_music', target=>'instrument', method=>'play' }
);
...
my $object = MyObject->new();
$object->instrument( MyInstrument->new );
$object->play_music;
SEE ALSO
See Class::MakeMethods for general information about this distribution.
See Class::MakeMethods::Standard for more about this family of
subclasses.
perl v5.14.22004-09-0MakeMethods::Standard::Universal(3)