MakeMethods::Docs::RelatedModules(3)

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

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

RELATED MODULES

  accessors

Distribution
    CPAN. 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
    CPAN.

Comments
    I have not yet reviewed this module in detail.

  Class::Accessor

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 ));

  Class::Class

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

  Class::Constructor

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' );

  Class::Classgen

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

  Class::Contract

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';
      }

  Class::Data::Inheritable

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.

  Class::Delegate

Distribution
    CPAN. Uploaded 12/0.

Comments
    I have not yet reviewed this module in detail.

  Class::Delegation

Distribution
    CPAN. Uploaded 12/01.

Comments
    I have not yet reviewed this module in detail.

  Class::Generate

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'
      ];

  Class::Hook

Distribution
    CPAN. Uploaded 12/01.

Comments
    I have not yet reviewed this module in detail.

  Class::Holon

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

  Class::MethodMaker

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.

  Class::MakeMethods

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' } ],
      );

  Class::Maker

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.

  Class::SelfMethods

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.

  Class::Struct

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.

  Class::StructTemplate

Distribution
    CPAN. Last update 12/00.

    No documentation available.

Usage
    Unknown.

Mechanism
    Unknown.

  Class::Template

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'
      };

  Class::Virtual
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.

  CodeGen::PerlBean

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.

  HTML::Mason::MethodMaker

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 ) ]
      );

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

  Attribute::Property

  Class::Accessor::Chained

  Class::Accessor::Lvalue

  Class::Accessor::Ref

  Class::AutoClass

  Class::Builder

  Class::Member

  Class::Trigger

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

CREDITS AND COPYRIGHT

  Developed By
  M. Simon Cavalletto, simonm@cavalletto.org
  Evolution Softworks, www.evoscript.org

  Copyright
Copyright 2002 Matthew Simon Cavalletto.

Portions copyright 2000, 2001 Evolution Online Systems, Inc.

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

POD ERRORS
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'