This distribution is deprecated. The features it provides have been added to
the Moose core code as Moose::Meta::Attribute::Native. This distribution should
not be used by any new code.

While Moose attributes provide you with a way to name your accessors, readers,
writers, clearers and predicates, this library provides commonly used attribute
helper methods for specific types of data.

This is an abstract role which provides an alternate constructor for creating
objects using parameters passed in from a configuration file. The actual
implementation of reading the configuration file is left to concrete subroles.

It declares an attribute configfile and a class method new_with_config, and
requires that concrete roles derived from it implement the class method
get_config_from_file.

Attributes specified directly as arguments to new_with_config supercede those
in the configfile.

MooseX::Getopt knows about this abstract role, and will use it if available to
load attributes from the file specified by the commandline flag --configfile
during its normal new_with_options.

This class allows to wrap any "Moose::Meta::TypeConstraint" in a way that
will force coercion of the value when checking or validating a value
against it.

If you've ever wanted to be able to call an attribute any number of things
while you're passing arguments to your object constructor, Now You Can.

The primary motivator is that I have some attributes that were named
inconsistently, and I wanted to rename them without breaking backwards
compatibility with my existing API.

"MooseX::NonMoose" allows for easily subclassing non-Moose classes with
Moose, taking care of the annoying details connected with doing this, such
as setting up proper inheritance from Moose::Object and installing (and
inlining, at "make_immutable" time) a constructor that makes sure things
like "BUILD" methods are called.

LONG DESCRIPTION
GOES
HERE

Your parameterized role consists of two new things: parameter declarations
and a 'role' block.

Parameters are declared using the the /parameter manpage keyword which very
much resembles the Moose/has manpage. You can use any option that the
Moose/has manpage accepts. The default value for the 'is' option is 'ro' as
that's a very common case. Use 'is => 'bare'' if you want no accessor.
These parameters will get their values when the consuming class (or role)
uses the Moose/with manpage. A parameter object will be constructed with
these values, and passed to the 'role' block.

The 'role' block then uses the usual the Moose::Role manpage keywords to
build up a role. You can shift off the parameter object to inspect what the
consuming class provided as parameters. You use the parameters to customize
your role however you wish.

There are many possible implementations for parameterized roles (hopefully
with a consistent enough API); I believe this to be the easiest and most
flexible design. Coincidentally, Pugs originally had an eerily similar
design.

See the MooseX::Role::Parameterized::Extending manpage for some tips on how
to extend this module.

This role loads simple configfiles to set object attributes. It is based on the
abstract role MooseX::ConfigFromFile, and uses Config::Any to load your
configfile. Config::Any will in turn support any of a variety of different
config formats, detected by the file extension. See Config::Any for more
details about supported formats.

Like all MooseX::ConfigFromFile -derived configfile loaders, this module is
automatically supported by the MooseX::Getopt role as well, which allows
specifying -configfile on the commandline.

A singleton is a class that has only one instance in an application.
"MooseX::Singleton" lets you easily upgrade (or downgrade, as it were)
your Moose class to a singleton.

All you should need to do to transform your class is to change "use Moose"
to "use MooseX::Singleton". This module uses metaclass roles to do its
magic, so it should cooperate with most other "MooseX" modules.

MooseX::Storage is a serialization framework for Moose, it provides a very
flexible and highly pluggable way to serialize Moose classes to a number of
different formats and styles.

Simply loading this module makes your constructors "strict". If your
constructor is called with an attribute init argument that your class does not
declare, then it calls "Carp::confess()". This is a great way to catch small
typos.

Often you want to create components that can be added to a class
arbitrarily. This module makes it easy for the end user to use these
components. Instead of requiring the user to create a named class with the
desired roles applied, or apply roles to the instance one-by-one, he can
just create a new class from yours with "with_traits", and then
instantiate that.

This module packages several Moose::Util::TypeConstraints with coercions,
designed to work with the DateTime suite of objects.

MooseX::Types::Path::Class creates common Moose types, coercions and option
specifications useful for dealing with Path::Class objects as Moose attributes.

Coercions (see Moose::Util::TypeConstraints) are made from both 'Str' and
'ArrayRef' to both Path::Class::Dir and Path::Class::File objects. If you have
MooseX::Getopt installed, the Getopt option type ("=s") will be added for both
Path::Class::Dir and Path::Class::File.

A structured type constraint is a standard container Moose type
constraint, such as an ArrayRef or HashRef, which has been enhanced to
allow you to explicitly name all the allowed type constraints inside the
structure.

This type library enables structured type constraints. It is built on top
of the MooseX::Types library system, so you should review the
documentation for that if you are not familiar with it.

Perl module for Mouse to organize your types into libraries.

This module implements the nameprep specification, which describes how to
prepare internationalized domain name (IDN) labels in order to increase the
likelihood that name input and name comparison work in ways that make sense for
typical users throughout the world. Nameprep is a profile of the stringprep
protocol and is used as part of a suite of on-the-wire protocols for
internationalizing the Domain Name System (DNS).

OAuth is "An open protocol to allow secure API authentication in a simple and
standard method from desktop and web applications."

In practical terms, OAuth is a mechanism for a Consumer to request protected
resources from a Service Provider on behalf of a user.

Please refer to the OAuth spec: http://oauth.net/documentation/spec

Net::OAuth provides:
* classes that encapsulate OAuth messages (requests and responses).
* message signing
* message serialization and parsing.
* 2-legged requests (aka. tokenless requests, aka. consumer requests),
see "CONSUMER REQUESTS"

Net::OAuth does not provide:
* Consumer or Service Provider encapsulation
* token/nonce/key storage/management

Net::Pcap is a Perl binding to the LBL pcap(3) library. The README for libpcap
describes itself as: "a system-independent interface for user-level packet
capture. libpcap provides a portable framework for low-level network
monitoring. Applications include network statistics collection, security
monitoring, network debugging, etc."

This module provides a perl interface to the Twitter APIs. See
for a full
description of the Twitter APIs.

"NetPacket" provides a base class for a cluster of modules related to
decoding and encoding of network protocols. Each "NetPacket" descendent
module knows how to encode and decode packets for the network protocol it
implements. Consult the documentation for the module in question for
protocol-specific implementation.
Note that there is no inheritance in the "NetPacket::" cluster of modules
other than each protocol module being a "NetPacket". This was seen to be
too restrictive as imposing inheritance relationships (for example between
the IP, UDP and TCP protocols) would make things like tunneling or other
unusual situations difficult.