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
MakeMethods::Docs::RelatedModules(3) User Contributed Perl Documentation MakeMethods::Docs::RelatedModules(3)

Class::MakeMethods::Docs::RelatedModules - Survey of Class Builders

  http://search.cpan.org/search?mode=module&query=Class

There are a variety of modules on CPAN dedicated to the purpose of generating common constructor and accessor methods. Below, I survey several of these, summarizing some basic features and technical approaches, and comparing them to Class::MakeMethods and other modules.

Please note that these comments are for basic comparison purposes only and may be incorrect or out of date. Please consult the documentation from a current version of each module for more specific details. Corrections and clarifications would by welcomed by the author at the email address below.

In general, I compared the following characteristics:
Distribution
Is it included with Perl, or on CPAN? Is it being actively maintained?
Usage
How do you go about declaring your class's methods?
Mechanism
How are they generated and delivered?
Instance type
Are the objects of your class blessed hashes, or something else?
Core Methods
Does the module provide a constructor and basic accessors? Are there specialized methods for hash-ref, array-ref, and object-ref accessors?
Extensible
Can you subclass the package to create new types of methods, or is there some other way to extend it?
Other Methods
Other types of methods provided.
Emulator
Does Class::MakeMethods provide a drop-in replacement for this module?
Comments
Other characteristics or features of note.

Distribution
CPAN. Uploaded Sep 2003.
Comments
I have not yet reviewed this module in detail.
Example
  package MyObject;
  use accessors qw( foo bar baz );
    

Distribution
CPAN.
Comments
I have not yet reviewed this module in detail.

Distribution
CPAN. Last update 4/01.
Usage
Inherit and call function with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Hash.
Subclasses Cleanly
Cleanly.
Standard Methods
Scalar accessors.
Extensible
Yes.
Comments
Accessor methods call overwritable "self-<get( key)" and "self-<set(key, value)" methods.

Also includes Class::Accessor::Fast, which creates direct hash keys accessors without calling get and set methods.

Emulator
Yes, but only for the Fast variation; see Class::MakeMethods::Emulator::AccessorFast.
Example
  package MyObject;
  @ISA = qw(Class::Accessor);
  MyObject->mk_accessors(qw( simple ordered mapping obj_ref ));
    

Distribution
CPAN. Last update 1/00.
Usage
Inherit and fill %MEMBERS hash; methods created when first object is created
Mechanism
Generates and installs closures
Instance Type
Hash.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and various accessors.
Extensible
No.
Example
Usage is similar to Class::Struct:

  package MyObject;
  use Class::Class; 
  @ISA = qw(Class::Class);
  %MEMBERS = ( 
    simple  => '$',
    ordered => '@',
    mapping => '%',
    obj_ref => 'FooObject' 
  );
    
Other Method Types
Provides a polymorph() method that is similar to Class::Method's "ClassName:class_name -require".

Distribution
CPAN. Last update 11/01.
Usage
Inherit and call function with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Hash.
Subclasses Cleanly
Cleanly.
Standard Methods
Hash constructor, with bells.
Extensible
No.
Emulator
No, but possible.
Example
  package MyObject;
  @ISA = qw(Class::Constructor);
  MyObject->mk_constructor( Name => 'new' );
    

Distribution
CPAN. Last update 12/00.
Usage
Pre-processor run against declaration files.
Mechanism
Assembles and saves code file
Instance Type
Hash.
Subclasses Cleanly
Yes. (I think.)
Standard Methods
Constructor and various accessors.
Extensible
No. (I think.)
Example
  header:
      package MyObject;
  variables:
      $simple
      @ordered
      %mapping
      $obj_ref
    

Distribution
CPAN. Last update 5/01.
Usage
Call function with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Scalar reference with external data storage.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and various accessors.
Extensible
Yes. (I think.)
Comments
Supports pre- and post-conditions, class invariants, and other software engineering goodies.
Example
  package MyObject;
  use Class::Contract;
  contract {
    ctor 'new';
    attr 'simple'  => SCALAR;
    attr 'ordered' => ARRAY;  
    attr 'mapping' => HASH;   
    attr 'obj_ref' => 'FooObject';   
  }
    

Distribution
CPAN. Last update 4/00.
Usage
Inherit and call function with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Class data, with inheritance.
Subclasses Cleanly
Yes, specifically.
Standard Methods
Scalar accessors.
Extensible
No.
Example
Usage is similar to Class::Accessor:

  package MyObject;
  @ISA = qw(Class::Data::Inheritable);
  MyObject->mk_classdata(qw( simple ordered mapping obj_ref ));
    
Emulator
Yes, Class::MakeMethods::Emulator::Inheritable, passes original test suite.

Distribution
CPAN. Uploaded 12/0.
Comments
I have not yet reviewed this module in detail.

Distribution
CPAN. Uploaded 12/01.
Comments
I have not yet reviewed this module in detail.

Distribution
CPAN. Last update 11/00.
Usage
Call function with declaration arguments
Mechanism
Assembles and evals code string, or saves code file.
Instance Type
Hash.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and accessors (scalar, array, hash, object, object array, etc).
Extensible
Unknown.
Comments
Handles private/protected limitations, pre and post conditions, assertions, and more.
Example
Usage is similar to Class::Struct:

  package MyObject;
  use Class::Generate;
  class MyObject => [ 
    simple  => '$',
    ordered => '@',
    mapping => '%',
    obj_ref => 'FooObject' 
  ];
    

Distribution
CPAN. Uploaded 12/01.
Comments
I have not yet reviewed this module in detail.

Distribution
CPAN. Experimental/Alpha release 07/2001.
Instance Type
Hash, array, or flyweight-index.
Subclasses Cleanly
No. (I think.)
Standard Methods
Constructor and scalar accessors; flywieght objects also get scalar mutator methods.
Extensible
No. (I think.)
Comments
I'm not sure I understand the intent of this module; perhaps future versions will make this clearer....

Distribution
CPAN. Last update 1/01.
Usage
Import, or call function, with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Hash, Static.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and various accessors.
Extensible
Yes.
Example
Usage is similar to Class::MakeMethods:

  package MyObject;
  use Class::MethodMaker (
    new     =>   'new',
    get_set =>   'simple',
    list    =>   'ordered',
    hash    =>   'mapping',
    object  => [ 'FooObject' => 'obj_ref' ],
  );
    
Emulator
Yes, Class::MakeMethods::Emulator::MethodMaker, passes original test suite.

Distribution
CPAN.
Usage
Import, or call function, with declaration arguments; or if desired, make methods on-demand with Autoload, or declare subroutines with a special Attribute.
Mechanism
Generates and installs closures
Instance Type
Hash, Array, Scalar, Static, Class data, others.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and various accessors.
Extensible
Yes.
Example
Usage is similar to Class::MethodMaker:

  package MyObject;
  use Class::MakeMethods::Hash (
    new    =>   'new',
    scalar =>   'simple',
    array  =>   'ordered',
    hash   =>   'mapping',
    object => [ 'obj_ref', { class=>'FooObject' } ],
  );
    

Distribution
CPAN. Last update 7/02.
Usage
Call function with declaration arguments.
Mechanism
Generates and installs closures (I think).
Instance Type
Hash (I think).
Subclasses Cleanly
Unknown.
Standard Methods
Constructor and various scalar and reference accessors.
Extensible
Unknown.
Comments
I haven't yet reviewed this module closely.

Distribution
CPAN. Last update 2/00.
Usage
Inherit; methods created via AUTOLOAD
Mechanism
Generates and installs closures (I think)
Instance Type
Hash.
Subclasses Cleanly
Yes.
Standard Methods
Constructor and scalar/code accessors (see Comments).
Extensible
No.
Comments
Individual objects may be assigned a subroutine that will be called as a method on subsequent accesses. If an instance does not have a value for a given accessor, looks for a method defined with a leading underscore.

Distribution
Included in the standard Perl distribution. Replaces Class::Template.
Usage
Call function with declaration arguments
Mechanism
Assembles and evals code string
Instance Type
Hash or Array
Subclasses Cleanly
No.
Standard Methods
Constructor and various accessors.
Extensible
No.

  package MyObject;
  use Class::Struct;
  struct( 
    simple  => '$',
    ordered => '@',
    mapping => '%',
    obj_ref => 'FooObject' 
  );
    
Emulator
Yes, Class::MakeMethods::Emulator::Struct.

Distribution
CPAN. Last update 12/00.

No documentation available.

Usage
Unknown.
Mechanism
Unknown.

Distribution
CPAN. Out of date.
Usage
Call function with declaration arguments (I think)
Mechanism
Assembles and evals code string (I think)
Instance Type
Hash.
Subclasses Cleanly
Yes. (I think.)
Standard Methods
Constructor and various accessors.
Extensible
No. (I think.)
Example
Usage is similar to Class::Struct:

  package MyObject;
  use Class::Template;
  members MyObject { 
    simple  => '$',
    ordered => '@',
    mapping => '%',
    obj_ref => 'FooObject' 
  };
    

Generates methods that fail with a message indicating that they were not implemented by the subclass. (Cf. 'Template::Universal:croak -abstract'.)

Also provides a list of abstract methods that have not been implemented by a subclass.

Distribution
CPAN. Last update 3/01.
Extensible
Unknown.
Mechanism
Uses Class::Data::Inheritable and installs additional closures.

Distribution
CPAN.
Usage
Call function with declaration arguments.
Mechanism
Generates and writes source code to a file.
Instance Type
Hash (I think).
Subclasses Cleanly
Unknown.
Standard Methods
Constructor and various scalar and reference accessors.
Extensible
Unknown.
Comments
I haven't yet reviewed this module closely.

Distribution
CPAN.
Usage
Package import with declaration arguments
Mechanism
Generates and installs closures
Instance Type
Hash.
Standard Methods
Scalar accessors.
Extensible
No.
Example
  use HTML::Mason::MethodMaker ( 
    read_write => [ qw( simple ordered mapping obj_ref ) ] 
  );
    

The following modules are relevant but have not yet been cataloged above.

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

  M. Simon Cavalletto, simonm@cavalletto.org
  Evolution Softworks, www.evoscript.org
Copyright 2002 Matthew Simon Cavalletto.

Portions copyright 2000, 2001 Evolution Online Systems, Inc.

You may use, modify, and distribute this document under the same terms as Perl.

Hey! The above document had some coding errors, which are explained below:
Around line 485:
'=item' outside of any '=over'
Around line 494:
You forgot a '=back' before '=head2'
2004-09-06 perl v5.32.1

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

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