CGI-Session is a Perl5 library that provides an easy, reliable and
modular session management system across HTTP requests. Persistency is
a key feature for such applications as shopping carts,
login/authentication routines, and application that need to carry data
across HTTP requests. CGI::Session does that and many more.

These manpages give you the most important information about Chart. There
is also a complete documentation (Documentation.pdf) within the Chart
package. Look at it to get more information. This module is an attempt to
build a general purpose graphing module that is easily modified and
expanded. I borrowed most of the API from Martien Verbruggen's GIFgraph
module. I liked most of GIFgraph, but I thought it was to difficult to
modify, and it was missing a few things that I needed, most notably
legends. So I decided to write a new module from scratch, and I've designed
it from the bottom up to be easy to modify. Like GIFgraph, Chart uses
Lincoln Stein's GD module for all of its graphics primitives calls.

Authors:
--------
David Bonner
Peter Clark
Chart-Group at BKG

Class-Factory module for perl

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.
Configuration files are a good example of this. There are four basic operations
you would want to do with any configuration: read the file in, lookup a value,
set a value, write the file out. There are also many different types of
configuration files, and you may want users to be able to provide an
implementation for their own home-grown configuration format.

Authors: Fred Moyer
is the current maintainer.

Chris Winters

Eric Andreychek
implemented overridable log/error capability and
prodded the module into a simpler design.

Srdjan Jankovic
contributed the idea for 'get_my_factory()' and 'get_my_factory_type()'

Sebastian Knapp
contributed the idea for 'get_registered_class()'

Marcel Gruenauer
contributed the methods 'remove_factory_type()'
and 'unregister_factory_type()'.

-------------------------------------------------------------------------------

Class-Fields module for perl

A collection of utility functions/methods for examining the data members of a
class. It provides a nice, high-level interface that should stand the test of time
and Perl upgrades nicely.

Author: Michael G Schwern

-------------------------------------------------------------------------------

Class-Observable module for perl

If you have ever used Java, you may have run across the java.util.Observable class
and the java.util.Observer interface. With them you can decouple an object from
the one or more objects that wish to be notified whenever particular events occur.

These events occur based on a contract with the observed item. They may occur at
the beginning, in the middle or end of a method. In addition, the object knows
that it is being observed. It just does not know how many or what types of
objects are doing the observing. It can therefore control when the messages
get sent to the obsevers.

The behavior of the observers is up to you. However, be aware that we do not do
any error handling from calls to the observers. If an observer throws a die,
it will bubble up to the observed item and require handling there. So be careful.

Throughout this documentation we refer to an 'observed item' or 'observable item'.
This ambiguity refers to the fact that both a class and an object can be observed.
The behavior when notifying observers is identical. The only difference comes in
which observers are notified.
(See "Observable Classes and Objects" for more information.)

Author: Chris Winters

-------------------------------------------------------------------------------

This module was written after having to write Yet Another Config File
Parser for some variety of colon-separated config. I decided "never again".

Config::Auto aims to be the most 'DWIM' config parser available, by
detecting configuration styles, include paths and even config filenames
automagically.

See the the HOW IT WORKS manpage section below on implementation details.

Config::Identity is a tool for loading (and optionally decrypting via GnuPG) user/pass identity information. For GitHub API access, an identity is a 'login'/'token' pair. For PAUSE access, an identity is a 'user'/'password' pair.

This module implements yet another damn configuration-file system.

The configuration language is deliberately simple and limited, and the
module works hard to preserve as much information (section order,
comments, etc.) as possible when a configuration file is updated.

Author: Damian Conway

Software distributions released to the CPAN include a _META.json_ or, for older distributions, _META.yml_, which describes the distribution, its contents, and the requirements for building and installing the distribution. The data structure stored in the _META.json_ file is described in the CPAN::Meta::Spec manpage.

CPAN::Meta provides a simple class to represent this distribution metadata (or _distmeta_), along with some helpful methods for interrogating that data.

The documentation below is only for the methods of the CPAN::Meta object. For information on the meaning of individual fields, consult the spec.