Class::MakeMethods::Docs::RelatedModules: Survey of class builders

SYNOPSIS

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

DESCRIPTION

There are a variety of modules on \s-1CPAN\s0 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.

Caution

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.

Points of Comparison

In general, I compared the following characteristics:

Distribution: Is it included with Perl, or on \s-1CPAN\s0? 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.

RELATED MODULES

accessors

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

Attribute::Property

Distribution: \s-1CPAN\s0.
Comments: I have not yet reviewed this module in detail.

Class::Accessor

Distribution: \s-1CPAN\s0. 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 \*(C`self-<get(key)\*(C' and \*(C`self-<set(key, value)\*(C' 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 ));

Class::Class

Distribution: \s-1CPAN\s0. 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 \*(L"ClassName:class_name -require\*(R".

Class::Constructor

Distribution: \s-1CPAN\s0. 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' );

Class::Classgen

Distribution: \s-1CPAN\s0. 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

Class::Contract

Distribution: \s-1CPAN\s0. 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'; }

Class::Data::Inheritable

Distribution: \s-1CPAN\s0. 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.

Class::Delegate

Distribution: \s-1CPAN\s0. Uploaded 12/0.
Comments: I have not yet reviewed this module in detail.

Class::Delegation

Distribution: \s-1CPAN\s0. Uploaded 12/01.
Comments: I have not yet reviewed this module in detail.

Class::Generate

Distribution: \s-1CPAN\s0. 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' ];

Class::Hook

Distribution: \s-1CPAN\s0. Uploaded 12/01.
Comments: I have not yet reviewed this module in detail.

Class::Holon

Distribution: \s-1CPAN\s0. 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....

Class::MethodMaker

Distribution: \s-1CPAN\s0. 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.