Reading and writing configuration files is one of the most frequent tasks of
any software design. Config::Simple is the library that helps you with it.

Config::Simple is a class representing configuration file object. It supports
several configuration file syntax and tries to identify the file syntax
automatically. Library supports parsing, updating and creating configuration
files.

Author:
-------
Sherzod B. Ruzmetov

BinHex is a format used by Macintosh for transporting Mac files safely through
electronic mail, as short-lined, 7-bit, semi-compressed data streams. This
module provides a means of converting those data streams back into binary
data.

This module provides utility functions for data and data types, including
functions for subroutines and symbol table hashes (stashes).

The implementation of this module is both Pure Perl and XS, so if you have
a C compiler, all the functions this module provides are really faster.

There are many benchmarks in the _DIST-DIR/benchmark/_ directory.

An implementation of the Mayan Long Count, Haab, and Tzolkin calendars as
defined in "Calendrical Calculations The Millennium Edition". Supplemented by
"Frequently Asked Questions about Calendars".

Author:
-------
Joshua Hoblitt

DateTime::Format::Builder creates DateTime parsers. Many string formats of
dates and times are simple and just require a basic regular expression to
extract the relevant information. Builder provides a simple way to do this
without writing reams of structural code.

Builder provides a number of methods, most of which you'll never need, or at
least rarely need. They're provided more for exposing of the module's innards
to any subclasses, or for when you need to do something slightly beyond what I
expected.

Author:
-------
Iain Truskett ,
Dave Rolsky

This module understands the formats used by MySQL for its DATE, DATETIME,
TIME, and TIMESTAMP data types. It can be used to parse these formats in
order to create DateTime objects, and it can take a DateTime object and
produce a string representing it in the MySQL format.

A unique flat-file database module, written in pure perl. True multi-level
hash/array support (unlike MLDBM, which is faked), hybrid OO / tie()
interface, cross-platform FTPable files, ACID transactions, and is quite
fast. Can handle millions of keys and unlimited levels without significant
slow-down. Written from the ground-up in pure perl -- this is NOT a
wrapper around a C-based DBM. Out-of-the-box compatibility with Unix, Mac
OS X and Windows.

Author:
-------
Rob Kinyon,
Joseph Huckaby,

The main purpose of this module is to provide an easy way to build a
profile to validate a data structure. It does this by giving you a set of
declarative keywords in the importing namespace.

Perl Convenience wrapper for the rsync(1) program. Written for rsync-2.3.2 and
updated for rsync-2.6.0 but should perform properly with most recent versions.

Author:
-------
Lee Eakin

The intent of File::ShareDir is to provide a companion to Class::Inspector and
File::HomeDir, modules that take a process that is well-known by advanced Perl
developers but gets a little tricky, and make it more available to the larger
Perl community.

Quite often you want or need your Perl module (CPAN or otherwise) to have
access to a large amount of read-only data that is stored on the file-system at
run-time.

On a linux-like system, this would be in a place such as /usr/share, however
Perl runs on a wide variety of different systems, and so the use of any one
location is unreliable.

Perl provides a little-known method for doing this, but almost nobody is aware
that it exists. As a result, module authors often go through some very strange
ways to make the data available to their code.

The most common of these is to dump the data out to an enormous Perl data
structure and save it into the module itself. The result are enormous
multi-megabyte .pm files that chew up a lot of memory needlessly.

Author:
-------
Adam Kennedy

GD::Barcode is a subclass of GD and allows you to create barcode image with GD.

This module based on "Generate Barcode Ver 1.02 By Shisei Hanai 97/08/22".

From 1.14, you can use this module even if no GD (except plot method).

Author:
-------
Kawai Takanori GCD00051@nifty.ne.jp

GnuPG::Interface and its associated modules are designed to provide an
object-oriented method for interacting with GnuPG, being able to perform
functions such as but not limited to encrypting, signing, decryption,
verification, and key-listing parsing.

How Data Member Accessor Methods are Created
Each module in the GnuPG::Interface bundle relies on Any::Moose to
generate the get/set methods used to set the object's data members.
_This is very important to realize._ This means that any data member
which is a list has special methods assigned to it for pushing,
popping, and clearing the list.

Understanding Bidirectional Communication
It is also imperative to realize that this package uses interprocess
communication methods similar to those used in the IPC::Open3 manpage
and the perlipc/"Bidirectional Communication with Another Process"
manpage, and that users of this package need to understand how to use
this method because this package does not abstract these methods for
the user greatly. This package is not designed to abstract this away
entirely (partly for security purposes), but rather to simply help
create 'proper', clean calls to GnuPG, and to implement key-listing
parsing. Please see the perlipc/"Bidirectional Communication with
Another Process" manpage to learn how to deal with these methods.

Using this package to do message processing generally invovlves
creating a GnuPG::Interface object, creating a GnuPG::Handles object,
setting some options in its *options* data member, and then calling a
method which invokes GnuPG, such as *clearsign*. One then interacts
with with the handles appropriately, as described in the
perlipc/"Bidirectional Communication with Another Process" manpage.

Under older perls this module provides a drop in compatible api to the
Hash::Util::FieldHash manpage using the perltie manpage. When the
Hash::Util::FieldHash manpage is available it will use that instead.

This way code requiring field hashes can benefit from fast, robust field
hashes on Perl 5.10 and newer, but still run on older perls that don't ship
with that module.

See the Hash::Util::FieldHash manpage for all the details of the API.

HTML::RewriteAttributes is designed for simple yet powerful HTML attribute
rewriting.

You simply specify a callback to run for each attribute and we do the rest for
you.

This module is designed to be subclassable to make handling special cases
eaiser. See the source for methods you can override.

Author:
-------
Shawn M Moore,

This is a simple standalone HTTP server. By default, it doesn't thread or fork.
It does, however, act as a simple frontend which can be used to build a
standalone web-based application or turn a CGI into one.

It is possible to use Net::Server classes to create forking, pre-forking, and
other types of more complicated servers; see "net_server".

Author:
-------
Jesse Vincent,

Finding the home country of a client using only the IP address can be
difficult. Looking up the domain name associated with that address can provide
some help, but many IP addresses are not reverse mapped to any useful domain, and
the most common domain (.com) offers no help when looking for country.

This module comes bundled with a database of countries where various IP
addresses have been assigned. Although the country of assignment will probably
be the country associated with a large ISP rather than the client herself, this
is probably good enough for most log analysis applications, and under test has
proved to be as accurate as reverse-DNS and WHOIS lookup.

JSON-RPC is a stateless and light-weight remote procedure call (RPC)
protocol for inter-networking applications over HTTP. It uses JSON as the
data format for of all facets of a remote procedure call, including all
application data carried in parameters.

The old modules - JSONRPC::Transport::HTTP and Apache::JSONRPC are deprecated.
Please try to use JSON::RPC::Server and JSON::RPC::Client which support both
JSON-RPC protocol version 1.1 and 1.0.

Stemming reduces related words to a common root form -- for instance,
"horse", "horses", and "horsing" all become "hors". Most commonly, stemming
is deployed as part of a search application, allowing searches for a given
term to match documents which contain other forms of that term.

This module allows you to map from US two-letter codes to statees and vice
versa.

Author:
-------
T. M. Brannon,

This simple locking scheme is not based on any file locking system calls
such as 'flock()' or 'lockf()' but rather relies on basic file system
primitives and properties, such as the atomicity of the 'write()' system
call. It is not meant to be exempt from all race conditions, especially
over NFS. The algorithm used is described below in the *ALGORITHM* section.

It is possible to customize the locking operations to attempt locking once
every 5 seconds for 30 times, or delete stale locks (files that are deemed
too ancient) before attempting the locking.

This module is a generalization of the functionality provided by
Apache::StatINC and Apache::Reload. It's designed to make it easy to do simple
iterative development when working in a persistent environment.

It does not require mod_perl.

Author:
-------
Jesse Vincent ,
Autrijus Tang

This module provides some useful test functions for Mouse based classes.
It is an experimental first release, so comments and suggestions are very
welcome.

Net::Whois::Raw queries WHOIS servers about domains. The module supports
recursive WHOIS queries. Also queries via HTTP is supported for some TLDs.

Setting the variables $OMIT_MSG and $CHECK_FAIL will match the results against
a set of known patterns. The first flag will try to omit the copyright
message/disclaimer, the second will attempt to determine if the search failed
and return undef in such a case.

IMPORTANT: these checks merely use pattern matching; they will work on several
servers but certainly not on all of them.

Author:
-------
Ariel Brosh schop@cpan.org
Gabor Szabo gabor@perl.org.il
Corris Randall corris@cpan.org
Walery Studennikov despair@cpan.org

A big part of good API design is that we should be able to be flexible in the
ways that we take parameters.

Params::Coerce attempts to encourage this, by making it easier to take a
variety of different arguments, while adding negligable additional complexity
to your code.

Author:
-------
Adam Kennedy

'Params::Util' provides a basic set of importable functions that makes
checking parameters a hell of a lot easier

While they can be (and are) used in other contexts, the main point behind
this module is that the functions *both* Do What You Mean, and Do The Right
Thing, so they are most useful when you are getting params passed into your
code from someone and/or somewhere else and you can't really trust the
quality.

Thus, 'Params::Util' is of most use at the edges of your API, where params
and data are coming in from outside your code.

The functions provided by 'Params::Util' check in the most strictly correct
manner known, are documented as thoroughly as possible so their exact
behaviour is clear, and heavily tested so make sure they are not fooled by
weird data and Really Bad Things.

To use, simply load the module providing the functions you want to use as
arguments (as shown in the SYNOPSIS).

To aid in maintainability, 'Params::Util' will *never* export by default.

You must explicitly name the functions you want to export, or use the
':ALL' param to just have it export everything (although this is not
recommended if you have any _FOO functions yourself with which future
additions to 'Params::Util' may clash)