Linux Certif

Toute la documentation sur la certification Linux LPI

Class::MakeMethods::Standard::Universal.3pm

NAME

Class::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.