1MakeMethods::Docs::RelaUtseedrMoCdounltersi(b3u)ted PerlMaDkoecMuemtehnotdast:i:oDnocs::RelatedModules(3)
2
6 Class::MakeMethods::Docs::RelatedModules - Survey of Class Builders
7
9 http://search.cpan.org/search?mode=module&query=Class
10
12 There are a variety of modules on CPAN dedicated to the purpose of gen‐
13 erating common constructor and accessor methods. Below, I survey sev‐
14 eral of these, summarizing some basic features and technical
15 approaches, and comparing them to Class::MakeMethods and other modules.
16 Caution
18 Please note that these comments are for basic comparison purposes only
20 and may be incorrect or out of date. Please consult the documentation
21 from a current version of each module for more specific details. Cor‐
22 rections and clarifications would by welcomed by the author at the
23 email address below.
24 Points of Comparison
26 In general, I compared the following characteristics:
28 Distribution
30 Is it included with Perl, or on CPAN? Is it being actively main‐
31 tained?
32 Usage
34 How do you go about declaring your class's methods?
35 Mechanism
37 How are they generated and delivered?
38 Instance type
40 Are the objects of your class blessed hashes, or something else?
41 Core Methods
43 Does the module provide a constructor and basic accessors? Are
44 there specialized methods for hash-ref, array-ref, and object-ref
45 accessors?
46 Extensible
48 Can you subclass the package to create new types of methods, or is
49 there some other way to extend it?
50 Other Methods
52 Other types of methods provided.
53 Emulator
55 Does Class::MakeMethods provide a drop-in replacement for this mod‐
56 ule?
57 Comments
59 Other characteristics or features of note.
60
62 accessors
63 Distribution
65 CPAN. Uploaded Sep 2003.
66 Comments
68 I have not yet reviewed this module in detail.
69 Example
71 package MyObject;
72 use accessors qw( foo bar baz );
73 Attribute::Property
75 Distribution
77 CPAN.
78 Comments
80 I have not yet reviewed this module in detail.
81 Class::Accessor
83 Distribution
85 CPAN. Last update 4/01.
86 Usage
88 Inherit and call function with declaration arguments
89 Mechanism
91 Generates and installs closures
92 Instance Type
94 Hash.
95 Subclasses Cleanly
97 Cleanly.
98 Standard Methods
100 Scalar accessors.
101 Extensible
103 Yes.
104 Comments
106 Accessor methods call overwritable "self-<get(key)" and
107 "self-<set(key, value)" methods.
108 Also includes Class::Accessor::Fast, which creates direct hash keys
110 accessors without calling get and set methods.
111 Emulator
113 Yes, but only for the Fast variation; see Class::MakeMethods::Emu‐
114 lator::AccessorFast.
115 Example
117 package MyObject;
118 @ISA = qw(Class::Accessor);
119 MyObject->mk_accessors(qw( simple ordered mapping obj_ref ));
120 Class::Class
122 Distribution
124 CPAN. Last update 1/00.
125 Usage
127 Inherit and fill %MEMBERS hash; methods created when first object
128 is created
129 Mechanism
131 Generates and installs closures
132 Instance Type
134 Hash.
135 Subclasses Cleanly
137 Yes.
138 Standard Methods
140 Constructor and various accessors.
141 Extensible
143 No.
144 Example
146 Usage is similar to Class::Struct:
147 package MyObject;
149 use Class::Class;
150 @ISA = qw(Class::Class);
151 %MEMBERS = (
152 simple => '$',
153 ordered => '@',
154 mapping => '%',
155 obj_ref => 'FooObject'
156 );
157 Other Method Types
159 Provides a polymorph() method that is similar to Class::Method's
160 "ClassName:class_name -require".
161 Class::Constructor
163 Distribution
165 CPAN. Last update 11/01.
166 Usage
168 Inherit and call function with declaration arguments
169 Mechanism
171 Generates and installs closures
172 Instance Type
174 Hash.
175 Subclasses Cleanly
177 Cleanly.
178 Standard Methods
180 Hash constructor, with bells.
181 Extensible
183 No.
184 Emulator
186 No, but possible.
187 Example
189 package MyObject;
190 @ISA = qw(Class::Constructor);
191 MyObject->mk_constructor( Name => 'new' );
192 Class::Classgen
194 Distribution
196 CPAN. Last update 12/00.
197 Usage
199 Pre-processor run against declaration files.
200 Mechanism
202 Assembles and saves code file
203 Instance Type
205 Hash.
206 Subclasses Cleanly
208 Yes. (I think.)
209 Standard Methods
211 Constructor and various accessors.
212 Extensible
214 No. (I think.)
215 Example
217 header:
218 package MyObject;
219 variables:
220 $simple
221 @ordered
222 %mapping
223 $obj_ref
224 Class::Contract
226 Distribution
228 CPAN. Last update 5/01.
229 Usage
231 Call function with declaration arguments
232 Mechanism
234 Generates and installs closures
235 Instance Type
237 Scalar reference with external data storage.
238 Subclasses Cleanly
240 Yes.
241 Standard Methods
243 Constructor and various accessors.
244 Extensible
246 Yes. (I think.)
247 Comments
249 Supports pre- and post-conditions, class invariants, and other
250 software engineering goodies.
251 Example
253 package MyObject;
254 use Class::Contract;
255 contract {
256 ctor 'new';
257 attr 'simple' => SCALAR;
258 attr 'ordered' => ARRAY;
259 attr 'mapping' => HASH;
260 attr 'obj_ref' => 'FooObject';
261 }
262 Class::Data::Inheritable
264 Distribution
266 CPAN. Last update 4/00.
267 Usage
269 Inherit and call function with declaration arguments
270 Mechanism
272 Generates and installs closures
273 Instance Type
275 Class data, with inheritance.
276 Subclasses Cleanly
278 Yes, specifically.
279 Standard Methods
281 Scalar accessors.
282 Extensible
284 No.
285 Example
287 Usage is similar to Class::Accessor:
288 package MyObject;
290 @ISA = qw(Class::Data::Inheritable);
291 MyObject->mk_classdata(qw( simple ordered mapping obj_ref ));
292 Emulator
294 Yes, Class::MakeMethods::Emulator::Inheritable, passes original
295 test suite.
296 Class::Delegate
298 Distribution
300 CPAN. Uploaded 12/0.
301 Comments
303 I have not yet reviewed this module in detail.
304 Class::Delegation
306 Distribution
308 CPAN. Uploaded 12/01.
309 Comments
311 I have not yet reviewed this module in detail.
312 Class::Generate
314 Distribution
316 CPAN. Last update 11/00.
317 Usage
319 Call function with declaration arguments
320 Mechanism
322 Assembles and evals code string, or saves code file.
323 Instance Type
325 Hash.
326 Subclasses Cleanly
328 Yes.
329 Standard Methods
331 Constructor and accessors (scalar, array, hash, object, object
332 array, etc).
333 Extensible
335 Unknown.
336 Comments
338 Handles private/protected limitations, pre and post conditions,
339 assertions, and more.
340 Example
342 Usage is similar to Class::Struct:
343 package MyObject;
345 use Class::Generate;
346 class MyObject => [
347 simple => '$',
348 ordered => '@',
349 mapping => '%',
350 obj_ref => 'FooObject'
351 ];
352 Class::Hook
354Distribution
356CPAN. Uploaded 12/01.
357Comments
359I have not yet reviewed this module in detail.
360
362Distribution
364 CPAN. Experimental/Alpha release 07/2001.
365Instance Type
367 Hash, array, or flyweight-index.
368Subclasses Cleanly
370 No. (I think.)
371Standard Methods
373 Constructor and scalar accessors; flywieght objects also get scalar muta‐
374 tor methods.
375Extensible
377 No. (I think.)
378Comments
380 I'm not sure I understand the intent of this module; perhaps future ver‐
381 sions will make this clearer....
382
384Distribution
386 CPAN. Last update 1/01.
387Usage
389 Import, or call function, with declaration arguments
390Mechanism
392 Generates and installs closures
393Instance Type
395 Hash, Static.
396Subclasses Cleanly
398 Yes.
399Standard Methods
401 Constructor and various accessors.
402Extensible
404 Yes.
405Example
407 Usage is similar to Class::MakeMethods:
408 package MyObject;
410 use Class::MethodMaker (
411 new => 'new',
412 get_set => 'simple',
413 list => 'ordered',
414 hash => 'mapping',
415 object => [ 'FooObject' => 'obj_ref' ],
416 );
417Emulator
419 Yes, Class::MakeMethods::Emulator::MethodMaker, passes original test
420 suite.
421
423Distribution
425 CPAN.
426Usage
428 Import, or call function, with declaration arguments; or if desired, make
429 methods on-demand with Autoload, or declare subroutines with a special
430 Attribute.
431Mechanism
433 Generates and installs closures
434Instance Type
436 Hash, Array, Scalar, Static, Class data, others.
437Subclasses Cleanly
439 Yes.
440Standard Methods
442 Constructor and various accessors.
443Extensible
445 Yes.
446Example
448 Usage is similar to Class::MethodMaker:
449 package MyObject;
451 use Class::MakeMethods::Hash (
452 new => 'new',
453 scalar => 'simple',
454 array => 'ordered',
455 hash => 'mapping',
456 object => [ 'obj_ref', { class=>'FooObject' } ],
457 );
458
460Distribution
462 CPAN. Last update 7/02.
463Usage
465 Call function with declaration arguments.
466Mechanism
468 Generates and installs closures (I think).
469Instance Type
471 Hash (I think).
472Subclasses Cleanly
474 Unknown.
475Standard Methods
477 Constructor and various scalar and reference accessors.
478Extensible
480 Unknown.
481Comments
483 I haven't yet reviewed this module closely.
484
486Distribution
488 CPAN. Last update 2/00.
489Usage
491 Inherit; methods created via AUTOLOAD
492Mechanism
494 Generates and installs closures (I think)
495Instance Type
497 Hash.
498Subclasses Cleanly
500 Yes.
501Standard Methods
503 Constructor and scalar/code accessors (see Comments).
504Extensible
506 No.
507Comments
509 Individual objects may be assigned a subroutine that will be called as a
510 method on subsequent accesses. If an instance does not have a value for a
511 given accessor, looks for a method defined with a leading underscore.
512
514Distribution
516 Included in the standard Perl distribution. Replaces Class::Template.
517Usage
519 Call function with declaration arguments
520Mechanism
522 Assembles and evals code string
523Instance Type
525 Hash or Array
526Subclasses Cleanly
528 No.
529Standard Methods
531 Constructor and various accessors.
532Extensible
534 No.
535 package MyObject;
537 use Class::Struct;
538 struct(
539 simple => '$',
540 ordered => '@',
541 mapping => '%',
542 obj_ref => 'FooObject'
543 );
544Emulator
546 Yes, Class::MakeMethods::Emulator::Struct.
547
549Distribution
551 CPAN. Last update 12/00.
552 No documentation available.
554Usage
556 Unknown.
557Mechanism
559 Unknown.
560
562Distribution
564 CPAN. Out of date.
565Usage
567 Call function with declaration arguments (I think)
568Mechanism
570 Assembles and evals code string (I think)
571Instance Type
573 Hash.
574Subclasses Cleanly
576 Yes. (I think.)
577Standard Methods
579 Constructor and various accessors.
580Extensible
582 No. (I think.)
583Example
585 Usage is similar to Class::Struct:
586 package MyObject;
588 use Class::Template;
589 members MyObject {
590 simple => '$',
591 ordered => '@',
592 mapping => '%',
593 obj_ref => 'FooObject'
594 };
595
597Generates methods that fail with a message indicating that they were not
599implemented by the subclass. (Cf. 'Template::Universal:croak -abstract'.)
600Also provides a list of abstract methods that have not been implemented by a
602subclass.
603Distribution
605 CPAN. Last update 3/01.
606Extensible
608 Unknown.
609Mechanism
611 Uses Class::Data::Inheritable and installs additional closures.
612
614Distribution
616 CPAN.
617Usage
619 Call function with declaration arguments.
620Mechanism
622 Generates and writes source code to a file.
623Instance Type
625 Hash (I think).
626Subclasses Cleanly
628 Unknown.
629Standard Methods
631 Constructor and various scalar and reference accessors.
632Extensible
634 Unknown.
635Comments
637 I haven't yet reviewed this module closely.
638
640Distribution
642 CPAN.
643Usage
645 Package import with declaration arguments
646Mechanism
648 Generates and installs closures
649Instance Type
651 Hash.
652Standard Methods
654 Scalar accessors.
655Extensible
657 No.
658Example
660 use HTML::Mason::MethodMaker (
661 read_write => [ qw( simple ordered mapping obj_ref ) ]
662 );
663
665 The following modules are relevant but have not yet been cataloged
666 above.
667 Attribute::Property
669 Class::Accessor::Chained
671 Class::Accessor::Lvalue
673 Class::Accessor::Ref
675 Class::AutoClass
677 Class::Builder
679 Class::Member
681 Class::Trigger
683
685 See Class::MakeMethods for general information about this distribution.
686
688 Developed By
689 M. Simon Cavalletto, simonm@cavalletto.org
691 Evolution Softworks, www.evoscript.org
692 Copyright
694 Copyright 2002 Matthew Simon Cavalletto.
696 Portions copyright 2000, 2001 Evolution Online Systems, Inc.
698 License
700 You may use, modify, and distribute this document under the same terms
702 as Perl.
703perl v5.8.8 2004-09-0M6akeMethods::Docs::RelatedModules(3)