CPAN::Mini provides a simple mechanism to build and update a minimal mirror
of the CPAN on your local disk. It contains only those files needed to
install the newest version of every distribution. Those files are:

* *

01mailrc.txt.gz

* *

02packages.details.txt.gz

* *

03modlist.data.gz

* *

the last non-developer release of every dist for every author

Blowfish is capable of strong encryption and can use key sizes up to 56
bytes (a 448 bit key). You're encouraged to take advantage of the full key
size to ensure the strongest encryption possible from this module.

This module is a Perl-only implementation of the cryptographic cipher block
chaining mode (CBC). In combination with a block cipher such as DES or
IDEA, you can encrypt and decrypt messages of arbitrarily long length. The
encrypted messages are compatible with the encryption format used by the
*OpenSSL* package.

The module implements the Crypt::CBC interface, which has the following
methods

* blocksize
=item keysize
=item encrypt
=item decrypt

This module implements the Rijndael cipher, which has just been selected as
the Advanced Encryption Standard.

The Crypt::SaltedHash module provides an object oriented interface to
create salted (or seeded) hashes of clear text data. The original
formalization of this concept comes from RFC-3112 and is extended by the
use of different digital agorithms.

CSS::Tiny is a perl class to read and write .css stylesheets with as little
code as possible, reducing load time and memory overhead. CSS.pm requires
about 2.6 meg or ram to load, which is a large amount of overhead if you
only want to do trivial things. Memory usage is normally scoffed at in
Perl, but in my opinion should be at least kept in mind.

Curses is the interface between Perl and your system's curses(3) library.
For descriptions on the usage of a given function, variable, or constant,
consult your system's documentation, as such information invariably varies
(:-) between different curses(3) libraries and operating systems. This
document describes the interface itself, and assumes that you already know
how your system's curses(3) library works.

LONG DESCRIPTION
GOES
HERE

Hashes are great for storing named data, but if you want more than one
entry for a name, you have to use a list of pairs. Even then, this is
really boring to write:

$values = [
foo => undef,
bar => undef,
baz => undef,
xyz => { ... },
];

Just look at all those undefs! Don't worry, we can get rid of those:

$values = [
map { $_ => undef } qw(foo bar baz),
xyz => { ... },
];

Aaaauuugh! We've saved a little typing, but now it requires thought to
read, and thinking is even worse than typing.

With Data::OptList, you can do this instead:

$values = Data::OptList::mkopt([
qw(foo bar baz),
xyz => { ... },
]);

This works by assuming that any defined scalar is a name and any
reference following a name is its value.

Author: Ricardo SIGNES,

Data::Peek started off as 'DDumper' being a wrapper module over the
Data::Dumper manpage, but grew out to be a set of low-level data
introspection utilities that no other module provided yet, using the lowest
level of the perl internals API as possible.

Data::Section provides an easy way to access multiple named chunks of line-
oriented data in your module's DATA section. It was written to allow
modules to store their own templates, but probably has other uses.

ShowTable.pm is a Perl 5 module which defines subroutines to print
arrays of data in nicely formatted listings. It uses one of four
possible formats: simple table, boxed table, list style, and
HTML-formatting.

This package consists of a C library and a Perl module (which uses the
C library, internally) for all kinds of date calculations based on the
Gregorian calendar (the one used in all western countries today),
thereby complying with all relevant norms and standards: ISO/R
2015-1971, DIN 1355 and, to some extent, ISO 8601 (where applicable).

(See also http://www.engelschall.com/u/sb/download/Date-Calc/DIN1355/
for a scan of part of the "DIN 1355" document (in German)).

The module of course handles year numbers of 2000 and above correctly
("Year 2000" or "Y2K" compliance) -- actually all year numbers from 1
to the largest positive integer representable on your system (which is
at least 32767) can be dealt with.

Note that this package EXTRAPOLATES the Gregorian calendar BACK until
the year 1 A.D. -- even though the Gregorian calendar was only adopted
in 1582 by most (not all) European countries, in obedience to the
corresponding decree of catholic pope Gregor I in that year.

Some (mainly protestant) countries continued to use the Julian calendar
(used until then) until as late as the beginning of the 20th century.

Finally, note that this package is not intended to do everything you
could ever imagine automagically for you; it is rather intended to
serve as a toolbox (in the best of UNIX spirit and traditions) which
should, however, always get you where you want to go.

Date::Manip is a series of modules designed to make any common date/time
manipulation easy to do. Operations such as comparing two times,
calculating a time a given amount of time from another, or parsing
international times are all easily done. From the very beginning, the main
focus of Date::Manip has been to be able to do ANY desired date/time
operation easily, not necessarily quickly. Also, it is definitely oriented
towards the type of operations we (as people) tend to think of rather than
those operations used routinely by computers. There are other modules that
can do a subset of the operations available in Date::Manip much quicker
than those presented here, so be sure to read the section SHOULD I USE
DATE::MANIP in the Date::Manip::Misc document before deciding which of the
Date and Time modules from CPAN is for you.

A date object with as little code as possible

DateTime::Locale is primarily a factory for the various locale subclasses.
It also provides some functions for getting information on all the
available locales.

If you want to know what methods are available for locale objects,
then please read the DateTime::Locale::Base documentation.

This class is the base class for all time zone objects. A time zone is
represented internally as a set of observances, each of which describes the
offset from GMT for a given time period.

Note that without the 'DateTime.pm' module, this module does not do much.
It's primary interface is through a 'DateTime' object, and most users will
not need to directly use 'DateTime::TimeZone' methods.

DBD::mysql is the Perl5 Database Interface driver for the MySQL database.
In other words: DBD::mysql is an interface between the Perl programming
language and the MySQL programming API that comes with the MySQL relational
database management system. Most functions provided by this programming API
are supported. Some rarely used functions are missing, mainly because noone
ever requested them. :-)

This module is needed to access ODBC databases from within Perl. The
module uses the unixODBC manager to connect to the database.

Module XBase provides access to XBase (dBase, Fox*) database files,
namely dbf, dbt, fpt, ndx, ntx, mdx, idx and cdx.

The DBI is a database access module for the Perl programming language.
It defines a set of methods, variables, and conventions that provide a
consistent database interface, independent of the actual database
being used.