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

       The Standard::Universal suclass of MakeMethods provides a [INCOMPLETE].

   CallingConventions
       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.

   DeclarationSyntax
       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.

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 overridden 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-Callmethodsbyname
       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-Concatenateresultsofothermethods
       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-Callanothermethod
       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-Useanotherobjecttoprovidemethod
       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 facilitate 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;

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

       See Class::MakeMethods for general information about this distribution.

       See Class::MakeMethods::Standard for more about this family of subclasses.

perl v5.36.0                                       2022-10-13              MakeMethods::Standard::Universal(3pm)

         package MyObject;
         use Class::MakeMethods::Standard::Universal (
           no_op => 'this',
           abstract => 'that',
           delegate => { name=>'play_music', target=>'instrument', method=>'play' },
         );