The Cache modules are designed to assist a developer in persisting
data for a specified period of time. Often these modules are used
in web applications to store data locally to save repeated and
redundant expensive calls to remote machines or databases.
This module provides a shared cache, using a memory mapped file. Very useful
for mod_perl applications. If routines are provided which interact with the
underlying data, access to the cache is completely transparent, and the module
handles all the details of refreshing cache contents, and updating underlying
data, if necessary.
This module does two things differently to the venerable
Class::Accessor::Fast:
- Fields are stored at arms-length within a single hash value of $self, rather
than directly in the $self blessed referent.
- new() allows mixin into an existing object, rather than creating and
returning a new blessed hashref.
Class::Data::Inheritable is for creating accessor/mutators to class
data. That is, if you want to store something about your class as a
whole (instead of about a single object). This data is then inherited
by your subclasses and can be overridden.
This is a simple module that factory classes can use to generate new
types of objects on the fly, providing a consistent interface to common
groups of objects.
Factory classes are used when you have different implementations for the
same set of tasks but may not know in advance what implementations you
will be using.
Class::Inspector allows you to get information about a loaded class.
Most or all of this information can be found in other ways, but they
aren't always very friendly, and usually involve a relatively high level
of Perl wizardry, or strange or unusual looking code. Class::Inspector
attempts to provide an easier, more friendly interface to this
information.
Class::NamedParms
Provides standard get/set/clear accessors for a class via named
parameter with forced lexical checking of named parameters
for validity and initialization validation. Lightweight and simple
to use. Designed as a base class for inheritance by other modules.
This is intended to act as a utility in order to natively clone data structures
via a simple Perl interface. Will ensure that all references will be separated
from the parent data structure, yet kept relative to the new structure (if need
be).
Class::Spiffy is a framework and methodology for doing object oriented
(OO) programming in Perl. Class::Spiffy combines the best parts of
Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation
class. It attempts to fix all the nits and warts of traditional Perl OO,
in a clean, straightforward and (perhaps someday) standard way.
Class::Tangram is a common base class originally intended for use with
Tangram objects, that gives you free constructors, access methods,
update methods, and a destructor that should help in breaking circular
references for you. Type checking is achieved by parsing the Tangram
schema for the object, which is contained within the object class in an
exported variable $schema.