Class::Default provides a mechanism to allow your class to take static
method calls and apply it to a default instantiation of an object. It
provides a flexibility to an API that allows it to be used more
comfortably in different situations.
This technique appears to be especially useful when writing modules
that you want to be used in either a single use or a persistent
environment. In a CGI like environment, you want the simplicity of a
static interface. You can call Class-method> directly, without having
to pass an instantiation around constantly.
Class::ErrorHandler provides an error-handling mechanism that's
generic enough to be used as the base class for a variety of OO
classes.
Class::OOorNO
Class::OOorNO helps your module handle the input for its subroutines
whether called in object-oriented style (as object methods or class
methods with the arrow syntax ->), or in functional programming style
(as subroutines imported to the caller's namespace via Exporter).
Class::Generate is a Perl5 module to simplify creating class
hierarchies. It offers typed or untyped scalar, array, and hash
members, required members, private members, methods (both
instance and class), and other common features of object-
oriented software development. Of course, you can implement all
these things without a special module, but doing it via
Class::Generate is much, much more concise. And furthermore,
it's much less error prone: if you are using Perl's -w flag,
Class::Generate will catch many class specification and usage
errors.
Class related functionality in Perl is broken up into a variety of
different modules. Class::Handle attempts to provide a convenient
object wrapper around the various different types of functions that can
be performed on a class.
Currently, Class::Handle provides what is effectively a combined API from
UNIVERSAL, Class::ISA and Class::Inspector for obtaining information
about a Class, and some additional task methods, such as load to common
tasks relating to classes.
Class::ObjectTemplate is a utility class to assist in the building
of other Object Oriented Perl classes. It was described in detail in
the O'Reilly book, "Advanced Perl Programming" by Sriram Srinivasam.
Class::Hook enables you to trace methods calls from your code to other classes.
Instead of putting 'use Foo;' in your code, simply type 'use Class::Hook;'.
The class Foo is unknown in your code. It will be magically caught by
Class::Hook which will call Foo itself. You can see Class::Hook as a kind of
relay.
You can setup a subroutine to be called before any call to Foo->amethod and a
subroutine to be called after the call. Your subs will receive all the
information that Foo->amethod will receive, so you can trace everything
between your code and Foo.
Class::ParmList
General named parameter list parser. Handles default values,
required vs allowed distinctions, optional name lexical checking,
multiple retrieval, and error reporting. Works well as a complement to
Class::NamedParms.
This module provides for efficient and simple prototype-based
programming in Perl. You can provide different subroutines for each
object, and also have objects inherit their behavior and state from
another object.
This is a simple, safe and streamlined toolkit for building inside-out
objects. Unlike most other inside-out object building modules already
on CPAN, this module aims for minimalism and robustness:
* Does not require derived classes to subclass it
* Uses no source filters, attributes or CHECK blocks
* Supports any underlying object type including foreign inheritance
* Does not leak memory on object destruction
* Overloading-safe
* Thread-safe for Perl 5.8 or better
* mod_perl compatible
* Makes no assumption about inheritance or initializer needs
It provides the minimal support necessary for creating safe inside-out
objects and generating flexible accessors.