Many applications require that a large set of results be broken down
into a smaller set of 'windows', or 'pages' in web language.
Array::Window implements an algorithm specifically for dealing with
these windows. It is very flexible and permissive, making adjustments
to the window as needed.
Bread::Board::Declare is a Moose extension which allows for declaring
Bread::Board container classes in a more straightforward and natural way. It
sets up Bread::Board::Container as the superclass, and creates services
associated with each attribute that you create.
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.