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.

DateTime is a class for the representation of date/time combinations,
and is part of the Perl DateTime project. For details on this project
please see http://datetime.perl.org/. The DateTime site has a FAQ which
may help answer many "how do I do X?" questions. The FAQ is at
http://datetime.perl.org/?FAQ.

It represents the Gregorian calendar, extended backwards in time before
its creation (in 1582). This is sometimes known as the "proleptic
Gregorian calendar". In this calendar, the first day of the calendar
(the epoch), is the first day of year 1, which corresponds to the date
which was (incorrectly) believed to be the birth of Jesus Christ.

The calendar represented does have a year 0, and in that way differs
from how dates are often written using "BCE/CE" or "BC/AD".

For infinite datetimes, please see the DateTime::Infinite module.

Author:
-------
Dave Rolsky

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.

DBIx::Transaction is a wrapper around DBI that helps you manage your
database transactions.

This module attempts to generate a stack dump from a core file by
locating the best available debugger (if any) and running it with the
appropriate arguments and command script.

This is a simple developer's tool for finding circular references in
objects and other types of references. Because of Perl's reference-count
based memory management, circular references will cause memory leaks.

Devel::Symdump is a Perl module that provides a convenient way to
inspect Perl's symbol table and the class hierarchy within a running
program.

HMAC is used for message integrity checks between two parties that share a
secret key, and works in combination with some other Digest algorithm,
usually MD5 or SHA-1. The HMAC mechanism is described in RFC 2104.

HMAC follow the common 'Digest::' interface, but the constructor takes the
secret key and the name of some other simple 'Digest::' as argument.

Perl interface to the RSA Data Security Inc. MD4 Message-Digest
Algorithm.

The Digest::SHA1 module allows the use of the NIST SHA-1 message digest
algorithm from within Perl programs. The algorithm takes a message of
arbitrary length as input and produces a 160-bit fingerprint or message
digest of the input as output.

The 'Error' package provides two interfaces. Firstly 'Error' provides a
procedural interface to exception handling. Secondly 'Error' is a base
class for errors/exceptions that can either be thrown, for subsequent
catch, or can simply be recorded.

Errors in the class 'Error' should not be thrown directly, but the user
should throw errors from a sub-class of 'Error'.

This module tries to make it easy to build Perl extensions that use
functions and typemaps provided by other perl extensions. This means that a
perl extension is treated like a shared library that provides also a C and
an XS interface besides the perl one.

This works as long as the base extension is loaded with the RTLD_GLOBAL
flag (usually done with a

sub dl_load_flags {0x01}

in the main .pm file) if you need to use functions defined in the module.

The basic scheme of operation is to collect information about a module in
the instance, and then store that data in the Perl library where it may be
retrieved later. The object can also reformat this information into the
data structures required by ExtUtils::MakeMaker's WriteMakefile function.

When creating a new Depends object, you give it a name, which is the name
of the module you are building. You can also specify the names of modules
on which this module depends. These dependencies will be loaded
automatically, and their typemaps, header files, etc merged with your new
object's stuff. When you store the data for your object, the list of
dependencies are stored with it, so that another module depending on your
needn't know on exactly which modules yours depends.

For example:

Gtk2 depends on Glib

Gnome2::Canvas depends on Gtk2

ExtUtils::Depends->new ('Gnome2::Canvas', 'Gtk2');
this command automatically brings in all the stuff needed
for Glib, since Gtk2 depends on it.

This module tries to figure out how to link C programs with Fortran
subroutines on your system. Basically one must add a list of Fortran
runtime libraries. The problem is their location and name varies with
each OS/compiler combination!

The pkg-config program retrieves information about installed libraries,
usually for the purposes of compiling against and linking to them.

ExtUtils::PkgConfig is a very simplistic interface to this utility,
intended for use in the Makefile.PL of perl extensions which bind libraries
that pkg-config knows. It is really just boilerplate code that you would've
written yourself.

File::Basename::Object is an object-oriented wrapper around
File::Basename. The goal is to allow pathnames to be presented and
manipulated easily.

This module provides subs that allow you to read or write entire files with
one simple call. They are designed to be simple to use, have flexible ways
to pass in or get the file contents and to be very efficient. There is also
a sub to read in all the files in a directory other than . and ..

These slurp/spew subs work for files, pipes and sockets, and stdio,
pseudo-files, and DATA.

File::Which was created to be able to get the paths to executable programs
on systems under which the `which' program wasn't implemented in the shell.

FileHandle::Unget is a drop-in replacement for FileHandle which allows
more than one byte to be placed back on the input. It supports an
ungetc(ORD) which can be called more than once in a row, and an
ungets(SCALAR) which places a string of bytes back on the input.

This module provides a way to obtain filesystem disk space information.
This is a Unix only distribution. If you want to gather this information
for Unix and Windows, use Filesys::DfPortable. The only major benefit of
using Filesys::Df over Filesys::DfPortable, is that Filesys::Df supports
the use of open filehandles as arguments.

This is an autoloadable interface module for libgd, a popular library
for creating and manipulating PNG files. With this library you can
create PNG images on the fly or modify existing files.

This version of GD no longer supports GIF output because of threats
from the legal department at Unisys. Source code that calls
$image->gif will have to be changed to call either $image->jpg or
$image->png to output in JPEG or PNG formats. The last version of GD
that supported GIF output was version 1.19.