This is a library for generating form letters, building HTML pages, or
filling in templates generally. A `template' is a piece of text that
has little Perl programs embedded in it here and there. When you `fill
in' a template, you evaluate the little programs and replace them with
their values.

This module implements the C3 algorithm. I have broken this out into it's
own module because I found myself copying and pasting it way too often for
various needs. Most of the uses I have for C3 revolve around class building
and metamodels, but it could also be used for things like dependency
resolution as well since it tends to do such a nice job of preserving local
precendence orderings.

This class lets you build groups of accessors that will call different
getters and setters.

This is pragma to change Perl 5's standard method resolution order from depth-
first left-to-right (a.k.a - pre-order) to the more sophisticated C3 method
resolution order.

Load mix-ins or components to your C3-based class.

This contains XS performance enhancers for Class::C3 version 0.16 and higher.
The main Class::C3 package will use this package automatically if it can
find it. Do not use this package directly, use Class::C3 instead.

This module won't do anything for you if you're running a version of Class::C3
older than 0.16. (It's not a dependency because it would be circular with the
optional dep from that package to this one).

Yet another implementation of an anonymous class with per object
overrideable methods, but with the added attraction of sort of working
dispatch to the parent class's method.

This is an SQL to OO mapper with an object API inspired by Class::DBI (and a compatibility layer as a springboard for porting) and a resultset API that allows abstract encapsulation of database operations. It aims to make representing queries in your code as perl-ish as possible while still providing access to as many of the capabilities of the database as possible, including retrieving related records from multiple tables in a single query, JOIN, LEFT JOIN, COUNT, DISTINCT, GROUP BY and HAVING support.

DBIx::Class can handle multi-column primary and foreign keys, complex queries and database-level paging, and does its best to only query the database in order to return something you've directly asked for. If a resultset is used as an iterator it only fetches rows off the statement handle as requested in order to minimise memory usage. It has auto-increment support for SQLite, MySQL, PostgreSQL, Oracle, SQL Server and DB2 and is known to be used in production on at least the first four, and is fork- and thread-safe out of the box (although your DBD may not be).

This module provides an object-based user interface essentially identical
to the one provided by the Win32::SerialPort module.

Wrapper Class for the various JSON classes.

This module will provide a coherent API to bring together the various JSON
modules currently on CPAN. This module will allow you to code to any JSON API
and have it work regardless of which JSON module is actually installed.

Other JSON modules require setting several parameters before calling the
conversion methods to do what I want. This module does things by default
that I think should be done when working with JSON in Perl. This module
also encodes and decodes faster than the JSON manpage.pm and the JSON::Syck
manpage in my benchmarks.

This means that any piece of data in Perl (assuming it's valid unicode)
will get converted to something in JSON instead of throwing an exception.
It also means that output will be strict JSON, while accepted input will be
flexible, without having to set any options.

For a list of changes in recent versions, see the documentation for the
JSON::DWIW::Changes manpage.

This module can be downloaded from the
http://www.cpan.org/authors/id/D/DO/DOWENS/ manpage.

This module converts Perl data structures to JSON and vice versa. Its
primary goal is to be *correct* and its secondary goal is to be *fast*.
To reach the latter goal it was written in C.

Beginning with version 2.0 of the JSON module, when both JSON and
JSON::XS are installed, then JSON will fall back on JSON::XS (this can
be overridden) with no overhead due to emulation (by inheriting
constructor and methods). If JSON::XS is not available, it will fall
back to the compatible JSON::PP module as backend, so using JSON instead
of JSON::XS gives you a portable JSON API that can be fast when you need
and doesn`t require a C compiler when that is a problem.

As this is the n-th-something JSON module on CPAN, what was the reason
to write yet another JSON module? While it seems there are many JSON
modules, none of them correctly handle all corner cases, and in most
cases their maintainers are unresponsive, gone missing, or not listening
to bug reports for other reasons.

Author:
-------
Marc Lehmann

Module::Find lets you find and use modules in categories. This can be very useful for auto-detecting driver or plugin modules. You can differentiate between looking in the category itself or in all subcategories.

If you want Module::Find to search in a certain directory on your harddisk (such as the plugins directory of your software installation), make sure you modify @INC before you call the Module::Find functions.

The "mro" namespace provides several utilities for dealing with method
resolution order and method caching in general in Perl 5.9.5 and higher.
This module provides those interfaces for earlier versions of Perl (back to
5.6.0 anyways).

It is a harmless no-op to use this module on 5.9.5+. That is to say, code
which properly uses MRO::Compat will work unmodified on both older Perls and
5.9.5+.

If you're writing a piece of software that would like to use the parts of
5.9.5+'s mro:: interfaces that are supported here, and you want compatibility
with older Perls, this is the module for you.

Some parts of this code will work better and/or faster with Class::C3::XS
installed (which is an optional prereq of Class::C3, which is in turn a prereq
of this package), but it's not a requirement.

This module never exports any functions. All calls must be fully qualified
with the mro:: prefix.

The interface documentation here serves only as a quick reference of what the
function basically does, and what differences between MRO::Compat and 5.9.5+
One should look out for. The main docs in 5.9.5's mro are the real interface
docs, and contain a lot of other useful information.

Combination distribution of File::Spec and Cwd

This module provides a convenient way to perform cleanup or other forms of
resource management at the end of a scope. It is particularly useful when
dealing with exceptions: the Scope::Guard constructor takes a reference to
a subroutine that is guaranteed to be called even if the thread of execution
is aborted prematurely. This effectively allows lexically-scoped "promises"
to be made that are automatically honoured by perl's garbage collector.

This module was inspired by the excellent DBIx::Abstract. However, in using that module I found that what I really wanted to do was generate SQL, but still retain complete control over my statement handles and use the DBI interface. So, I set out to create an abstract SQL generation module.

This framework is intended to support unit testing in an object-oriented development paradigm (with support for inheritance of tests etc.) and is derived from the JUnit testing framework for Java by Kent Beck and Erich Gamma.

This framework provides lighter version of Test::Unit framework. It implements some of the Test::Unit classes and methods needed to run test units. The Test::Unit::Lite tries to be compatible with public API of Test::Unit. It doesn't implement all classes and methods at 100% and only those necessary to run tests are available.

The Test::Unit::Lite can be distributed as a part of package distribution, so the package can be distributed without dependency on modules outside standard Perl distribution. The Test::Unit::Lite is provided as a single file.

This is a library for generating form letters, building HTML pages, or
filling in templates generally. A `template' is a piece of text that
has little Perl programs embedded in it here and there. When you `fill
in' a template, you evaluate the little programs and replace them with
their values.

This module implements the C3 algorithm. I have broken this out into it's
own module because I found myself copying and pasting it way too often for
various needs. Most of the uses I have for C3 revolve around class building
and metamodels, but it could also be used for things like dependency
resolution as well since it tends to do such a nice job of preserving local
precendence orderings.

This class lets you build groups of accessors that will call different
getters and setters.

This is pragma to change Perl 5's standard method resolution order from depth-
first left-to-right (a.k.a - pre-order) to the more sophisticated C3 method
resolution order.

Load mix-ins or components to your C3-based class.

This contains XS performance enhancers for Class::C3 version 0.16 and higher.
The main Class::C3 package will use this package automatically if it can
find it. Do not use this package directly, use Class::C3 instead.

This module won't do anything for you if you're running a version of Class::C3
older than 0.16. (It's not a dependency because it would be circular with the
optional dep from that package to this one).