Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
MakeMethods::Standard:UservContributed PerlMakeMethods::Standard::Universal(3)

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:

       o   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:

       o   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:

       o   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:

       o   Has a list of other methods names as	an arrayref in the 'methods'
	   parameter. Required.

       o   When	called,	calls each of the named	method on itself, in order,
	   and returns the concatenation of their results.

       o   If a	'join' parameter is provided it	is included between each
	   method result.

       o   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:

       o   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:

       o   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.24.1			  2004-09-0MakeMethods::Standard::Universal(3)

NAME | SYNOPSIS | DESCRIPTION | METHOD GENERATOR TYPES | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Class::MakeMethods::Standard::Universal&sektion=3&manpath=FreeBSD+12.0-RELEASE+and+Ports>

home | help