GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  CLASS::MAKEMETHODS::STANDARD::UNIVERSAL (3)

.ds Aq ’

NAME

Class::MakeMethods::Standard::Universal - Generic Methods

CONTENTS

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,
  );
  ...
 
  # Doesnt 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:



  Cant 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. <B>RequiredB>.
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.

Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MAKEMETHODS::STANDARD::UNIVERSAL (3) 2004-09-06

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.