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.