The Badger toolkit is a collection of Perl modules designed to simplify
the process of building object-oriented Perl applications. It provides a
set of foundation classes upon which you can quickly build robust and
reliable systems that are simple, sexy and scalable.
CPANPLUS::Dist::Build is a distribution class for Module::Build
related modules.
Using this package, you can create, install and uninstall perl
modules. It inherits from CPANPLUS::Dist.
Normal users won't have to worry about the interface to this module,
as it functions transparently as a plug-in to CPANPLUS and will
just Do The Right Thing when it's loaded.
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).