Are you sick of trying to remember whether a particular helper is defined
in "List::Util" or "List::MoreUtils"? I sure am. Now you don't have to
remember. This module will export all of the functions that either of
those two modules defines.

Log::Log4perl lets you remote-control and fine-tune the logging behaviour
of your system from the outside. It implements the widely popular
(Java-based) Log4j logging package in pure Perl.

*For a detailed tutorial on Log::Log4perl usage, please read*

http://www.perl.com/pub/a/2002/09/11/log4perl.html

Logging beats a debugger if you want to know what's going on in your code
during runtime. However, traditional logging packages are too static and
generate a flood of log messages in your log files that won't help you.

'Log::Log4perl' is different. It allows you to control the number of
logging messages generated at three different levels:

* *

At a central location in your system (either in a configuration file or
in the startup code) you specify _which components_ (classes, functions)
of your system should generate logs.

* *

You specify how detailed the logging of these components should be by
specifying logging _levels_.

* *

You also specify which so-called _appenders_ you want to feed your log
messages to ("Print it to the screen and also append it to /tmp/my.log")
and which format ("Write the date first, then the file name and line
number, and then the log message") they should be in.

This is a very powerful and flexible mechanism. You can turn on and off
your logs at any time, specify the level of detail and make that dependent
on the subsystem that's currently executed.

Let me give you an example: You might find out that your system has a
problem in the 'MySystem::Helpers::ScanDir' component. Turning on detailed
debugging logs all over the system would generate a flood of useless log
messages and bog your system down beyond recognition. With 'Log::Log4perl',
however, you can tell the system: "Continue to log only severe errors to
the log file. Open a second log file, turn on full debug logs in the
'MySystem::Helpers::ScanDir' component and dump all messages originating
from there into the new log file". And all this is possible by just
changing the parameters in a configuration file, which your system can
re-read even while it's running!

This module provides functions for handling media (also known as MIME)
types and encodings. The mapping from file extensions to media types is
defined by the _media.types_ file. If the _~/.media.types_ file exists it
is used instead. For backwards compatibility we will also look for
_~/.mime.types_.

Mail::SPF is an object-oriented implementation of Sender Policy Framework
(SPF). See http://www.openspf.org for more information about SPF.

This class collection aims to fully conform to the SPF specification (RFC 4408)
so as to serve both as a production quality SPF implementation and as a
reference for other developers of SPF implementations.

a set of perl modules related to mail applications

MIME::Charset provides informations about character sets used for MIME messages
on Internet.

modules for parsing (and creating!) MIME entities

`Module::Build' is a system for building, testing, and installing Perl modules. It is meant to be an alternative to `ExtUtils::MakeMaker'. Developers may alter the behavior of the module through subclassing in a much more straightforward way than with `MakeMaker'. It also does not require a `make' on your system - most of the `Module::Build' code is
pure-perl and written in a very cross-platform way. In fact, you don`t even need a shell, so even platforms like MacOS (traditional) can use it fairly easily. Its only prerequisites are modules that are included with perl 5.6.0, and it works fine on perl 5.005 if you can install a few additional modules.

Module::Find lets you find and use modules in categories. This can be very useful for auto-detecting driver or plugin modules. You can differentiate between looking in the category itself or in all subcategories.

If you want Module::Find to search in a certain directory on your harddisk (such as the plugins directory of your software installation), make sure you modify @INC before you call the Module::Find functions.

This module deals with the examination of the namespace of Perl modules.
The contents of the module namespace is split across several physical
directory trees, but this module hides that detail, providing instead
a view of the abstract namespace.

Faster alternative to Net::CIDR when merging a large number of CIDR
address ranges. Works for IPv4 and IPv6 addresses.

Authors:
--------
Douglas Wilson

Net::DNS is a Perl interface to the DNS resolver. It allows the programmer to perform any type of DNS query from a Perl script. For details and examples, please read the Net::DNS manual page.

The 'Net::HTTP' class is a low-level HTTP client. An instance of the
'Net::HTTP' class represents a connection to an HTTP server. The HTTP
protocol is described in RFC 2616. The 'Net::HTTP' class supports
'HTTP/1.0' and 'HTTP/1.1'.

'Net::HTTP' is a sub-class of 'IO::Socket::INET'. You can mix the methods
described below with reading and writing from the socket directly. This is
not necessary a good idea, unless you know what you are doing.

You can either use the simple interface, which does one ident lookup at a
time, or use the asynchronous interface to perform (possibly) many
simultaneous lookups, or simply continue serving other things while the
lookup is proceeding.

NOTE: Automatically created during Factory devel project migration by admin.

Net::Server is an extensible, generic Perl server engine. Net::Server combines the good properties from Net::Daemon (0.34), NetServer::Generic (1.03), and Net::FTPServer (1.0), and also from various concepts in the Apache Webserver.

The Net::SNMP module implements an object oriented interface to the
Simple Network Management Protocol.

NOTE: Automatically created during Factory devel project migration by admin.

Net::Telnet allows you to make client connections to a TCP port and do
network I/O, especially to a port using the TELNET protocol. Simple
I/O methods such as print, get, and getline are provided. More
sophisticated interactive features are provided because connecting to a
TELNET port ultimately means communicating with a program designed for
human interaction. These interactive features include the ability to
specify a time-out and to wait for patterns to appear in the input
stream, such as the prompt from a shell.

Number::Compare compiles a simple comparison to an anonymous subroutine, which you can call with a value to be tested again.
Now this would be very pointless, if Number::Compare didn't understand magnitudes.
The target value may use magnitudes of kilobytes (k, ki), megabytes (m, mi), or gigabytes (g, gi). Those suffixed with an i use the appropriate 2**n version in accordance with the IEC standard: http://physics.nist.gov/cuu/Units/binary.html

Manipulating stashes (Perl's symbol tables) is occasionally necessary, but
incredibly messy, and easy to get wrong. This module hides all of that
behind a simple API.

NOTE: Most methods in this class require a variable specification that
includes a sigil. If this sigil is absent, it is assumed to represent the
IO slot.

Due to limitations in the typeglob API available to perl code, and to
typeglob manipulation in perl being quite slow, this module provides two
implementations - one in pure perl, and one using XS. The XS implementation
is to be preferred for most usages; the pure perl one is provided for cases
where XS modules are not a possibility. The current implementation in use
can be set by setting '$ENV{PACKAGE_STASH_IMPLEMENTATION}' or
'$Package::Stash::IMPLEMENTATION' before loading Package::Stash (with the
environment variable taking precedence), otherwise, it will use the XS
implementation if possible, falling back to the pure perl one.