Carp::Assert is intended for a purpose like the ANSI C library assert.h

This module is based on "'Carp.pm'" from Perl 5.005_03. It has been
modified to skip all package names matching the pattern given in the "use"
statement inside the "'qw()'" term (or argument list).

Suppose you have a family of modules or classes named "Pack::A", "Pack::B"
and so on, and each of them uses "'Carp::Clan qw(^Pack::);'" (or at least
the one in which the error or warning gets raised).

Thus when for example your script "tool.pl" calls module "Pack::A", and
module "Pack::A" calls module "Pack::B", an exception raised in module
"Pack::B" will appear to have originated in "tool.pl" where "Pack::A" was
called, and not in "Pack::A" where "Pack::B" was called, as the unmodified
"'Carp.pm'" would try to make you believe ':-)'.

This works similarly if "Pack::B" calls "Pack::C" where the exception is
raised, etcetera.

In other words, this blames all errors in the "'Pack::*'" modules on the
user of these modules, i.e., on you. ';-)'

The skipping of a clan (or family) of packages according to a pattern
describing its members is necessary in cases where these modules are not
classes derived from each other (and thus when examining '@ISA' - as in the
original "'Carp.pm'" module - doesn't help).

The purpose and advantage of this is that a "clan" of modules can work
together (and call each other) and throw exceptions at various depths down
the calling hierarchy and still appear as a monolithic block (as though
they were a single module) from the perspective of the caller.

In case you just want to ward off all error messages from the module in
which you "'use Carp::Clan'", i.e., if you want to make all error messages
or warnings to appear to originate from where your module was called (this
is what you usually used to "'use Carp;'" for ';-)'), instead of in your
module itself (which is what you can do with a "die" or "warn" anyway), you
do not need to provide a pattern, the module will automatically provide the
correct one for you.

I.e., just "'use Carp::Clan;'" without any arguments and call "carp" or
"croak" as appropriate, and they will automatically defend your module
against all blames!

In other words, a pattern is only necessary if you want to make several
modules (more than one) work together and appear as though they were only
one.

Forcing a Stack Trace
As a debugging aid, you can force "'Carp::Clan'" to treat a "croak" as
a "confess" and a "carp" as a "cluck". In other words, force a detailed
stack trace to be given. This can be very helpful when trying to
understand why, or from where, a warning or error is being generated.

This feature is enabled either by "importing" the non-existent symbol
'verbose', or by setting the global variable "'$Carp::Clan::Verbose'"
to a true value.

You would typically enable it by saying

use Carp::Clan qw(verbose);

Note that you can both specify a "family pattern" and the string
"verbose" inside the "'qw()'" term (or argument list) of the "use"
statement, but consider that a pattern of packages to skip is pointless
when "verbose" causes a full stack trace anyway.

CGI::FastTemplate manages templates and parses templates replacing
variable names with values. It was designed for mid to large scale
web applications (CGI, mod_perl) where there are great benefits to
separating the logic of an application from the specific
implementation details.

Author: Jason Moore

Checkbot is a perl5 script which can verify links within a region of
the World Wide Web. It checks all pages within an identified region,
and all links within that region. After checking all links within the
region, it will also check all links which point outside of the
region, and then stop.

Checkbot regularly writes reports on its findings, including all
servers found in the region, and all links with problems on those
servers.

Checkbot was written originally to check a number of servers at
once. This has implied some design decisions, so you might want to
keep that in mind when making suggestions. Speaking of which, be sure
to check the to do file on the website for things which have been
suggested for Checkbot.

This module automatically generates accessor/mutators for your class.

Class::Autouse allows you to specify a class the will only load when a
method of that class is called. For large classes that might not be
used during the running of a program, such as Date::Manip, this can
save you large amounts of memory, and decrease the script load time.

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 overriden.

For example:

Pere::Ubu->mk_classdata('Suitcase');

will generate the method Suitcase() in the class Pere::Ubu.

This new method can be used to get and set a piece of class data.

Pere::Ubu->Suitcase('Red');
$suitcase = Pere::Ubu->Suitcase;

The interesting part happens when a class inherits from Pere::Ubu:

package Raygun;
use base qw(Pere::Ubu);

# Raygun's suitcase is Red.
$suitcase = Raygun->Suitcase;

Raygun inherits its Suitcase class data from Pere::Ubu.

Inheritance of class data works analogous to method inheritance. As long as
Raygun does not "override" its inherited class data (by using Suitcase() to
set a new value) it will continue to use whatever is set in Pere::Ubu and
inherit further changes:

# Both Raygun's and Pere::Ubu's suitcases are now Blue
Pere::Ubu->Suitcase('Blue');

However, should Raygun decide to set its own Suitcase() it has now
"overridden" Pere::Ubu and is on its own, just like if it had overriden a
method:

# Raygun has an orange suitcase, Pere::Ubu's is still Blue.
Raygun->Suitcase('Orange');

Now that Raygun has overridden Pere::Ubu futher changes by Pere::Ubu no
longer effect Raygun.

# Raygun still has an orange suitcase, but Pere::Ubu is using Samsonite.
Pere::Ubu->Suitcase('Samsonite');

This module is intended to provide a general-purpose date and datetime
type for perl. You have a Class::Date class for absolute date and
datetime and have a Class::Date::Rel class for relative dates.

You can use "+", "-", "<" and ">" operators as with native perl data
types.

Class::Multimethods -- Supports multimethods and subroutine overloading
in Perl.

This is the "Class::Singleton" module. A Singleton describes an object
class that can have only one instance in any system. An example of a
Singleton might be a print spooler or system registry. This module
implements a Singleton class from which other classes can be derived. By
itself, the "Class::Singleton" module does very little other than manage
the instantiation of a single object. In deriving a class from
"Class::Singleton", your module will inherit the Singleton instantiation
method and can implement whatever specific functionality is required.

For a description and discussion of the Singleton class, see "Design
Patterns", Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.

Author: Andy Wardley

It's possible to accidentally inherit an AUTOLOAD method. Often this
will happen if a class somewhere in the chain uses AutoLoader or
defines one of their own. This can lead to confusing error messages
when method lookups fail.

Sometimes you want to avoid this accidental inheritance. In that case,
inherit from Class::WhiteHole. All unhandled methods will produce
normal Perl error messages.

Config::IniFiles provides a way to have readable configuration files
outside your Perl script. Configurations can be imported (inherited,
stacked,...), sections can be grouped, and settings can be accessed from a
tied hash.

Convert::ASN1 encodes and decodes ASN.1 data structures using BER/DER
rules.

Convert::BER is a Perl object class implementation for encoding and
decoding objects as described by ITU-T standard X.209 (ASN.1) using
Basic Encoding Rules (BER).

WARNING this module is no longer supported, See Convert::ASN1

Perl module to read TNEF files

Perl interface to the uulib library

Many online services that are centered around CPAN attempt to
associate multiple uploads by extracting a distribution name from the
filename of the upload. For most distributions this is easy as they
have used ExtUtils::MakeMaker or Module::Build to create the
distribution, which results in a uniform name. But sadly not all
uploads are created in this way.

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.

Crypt::Blowfish has the following methods:

blocksize()
keysize()
encrypt()
decrypt()

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.

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.

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,

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.