This module implements the C3 algorithm. I have broken this out into it's own module because I found myself copying and pasting it way too often for various needs. Most of the uses I have for C3 revolve around class building and metamodels, but it could also be used for things like dependency resolution as well since it tends to do such a nice job of preserving local precendence orderings.

Below is a brief explanation of C3 taken from the Class::C3 module. For more detailed information, see the "SEE ALSO" section and the links there.

This class lets you build groups of accessors that will call different getters and setters.

This is pragma to change Perl 5's standard method resolution order from depth-first left-to-right (a.k.a - pre-order) to the more sophisticated C3 method resolution order.

Load mix-ins or components to your C3-based class.

This contains XS performance enhancers for Class::C3 version 0.16 and higher. The main Class::C3 package will use this package automatically if it can find it. Do not use this package directly, use Class::C3 instead.

The test suite here is not complete, although it does verify a few basic things. The best testing comes from running the Class::C3 test suite *after* this module is installed.

This module won't do anything for you if you're running a version of Class::C3 older than 0.16. (It's not a dependency because it would be circular with the optional dep from that package to this one).

Yet another implementation of an anonymous class with per object overrideable methods, but with the added attraction of sort of working dispatch to the parent class's method.

This module provides a simple means to define abstract class interfaces, which can be used to program using the concepts of interface polymorphism.

This module is an alternative to Class::Singleton and Class::WeakSingleton, and provides a more secure Singleton class in that it takes steps to prevent the possibility of accidental creation of multiple instances and/or the overwriting of existsing Singleton instances.

This module implements a minimal lightweight exception object. It is meant to be a compromise between more basic solutions like Carp which can only print information and cannot handle exception objects, and more more complex solutions like Exception::Class which can be used to define complex inline exceptions and has a number of module dependencies.

Config::Tiny is a perl class to read and write .ini style configuration files with as little code as possible, reducing load time and memory overhead. Most of the time it is accepted that Perl applications use a lot of memory and modules. The ::Tiny family of modules is specifically intended to provide an ultralight alternative to the standard modules.

This module is primarily for reading human written files, and anything we write shouldn't need to have documentation/comments. If you need something with more power move up to Config::Simple, Config::General or one of the many other Config:: modules. To rephrase, Config::Tiny does not preserve your comments, whitespace, or the order of your config file.

RFCs 2822 and 822 specify date formats to be used by email. This module parses and emits such dates.

RFC2822 (April 2001) introduces a slightly different format of date than that used by RFC822 (August 1982). The main correction is that the preferred format is more limited, and thus easier to parse programmatically.

This module understands the W3CDTF date/time format, an ISO 8601 profile, defined at http://www.w3.org/TR/NOTE-datetime. This format as the native date format of RSS 1.0.
It can be used to parse these formats in order to create the appropriate objects.

This is an SQL to OO mapper with an object API inspired by Class::DBI (and a compatibility layer as a springboard for porting) and a resultset API that allows abstract encapsulation of database operations. It aims to make representing queries in your code as perl-ish as possible while still providing access to as many of the capabilities of the database as possible, including retrieving related records from multiple tables in a single query, JOIN, LEFT JOIN, COUNT, DISTINCT, GROUP BY and HAVING support.

DBIx::Class can handle multi-column primary and foreign keys, complex queries and database-level paging, and does its best to only query the database in order to return something you've directly asked for. If a resultset is used as an iterator it only fetches rows off the statement handle as requested in order to minimise memory usage. It has auto-increment support for SQLite, MySQL, PostgreSQL, Oracle, SQL Server and DB2 and is known to be used in production on at least the first four, and is fork- and thread-safe out of the box (although your DBD may not be).

This wrapper intercepts all requests. If some request fails this module detects the reason of fail. If the reason was database connection problem then wrapper would automatically reconnect and restart the query. Otherwise it would rethrow the exception.

Device::Modem class implements basic AT (Hayes) compliant device abstraction. It can be inherited by sub classes (as Device::Gsm), which are based on serial connections.

This module provides an object-based user interface essentially identical to the one provided by the Win32::SerialPort module.

File::Find::Rule is a friendlier interface to File::Find. It allows you to build rules which specify the desired files and directories.

IO provides a simple mechanism to load several of the IO modules in one go. The IO modules belonging to the core are:
IO::Handle
IO::Seekable
IO::File
IO::Pipe
IO::Socket
IO::Dir
IO::Select
IO::Poll

This module provide a lightweight IOC or Inversion of Control framework. Inversion of Control, sometimes called Dependency Injection, is a component management style which aims to clean up component configuration and provide a cleaner, more flexible means of configuring a large application.

Wrapper Class for the various JSON classes.

Other JSON modules require setting several parameters before calling the conversion methods to do what I want. This module does things by default that I think should be done when working with JSON in Perl. This module also encodes and decodes faster than JSON.pm and JSON::Syck in my benchmarks.

This means that any piece of data in Perl (assuming it's valid unicode) will get converted to something in JSON instead of throwing an exception. It also means that output will be strict JSON, while accepted input will be flexible, without having to set any options.

This module converts Perl data structures to JSON and vice versa. Its primary goal is to be correct and its secondary goal is to be fast. To reach the latter goal it was written in C.

Math::Calc::Units is a simple calculator that keeps track of units. It
currently handles combinations of byte sizes and duration only, although adding
any other multiplicative types is easy. Any unknown type is treated as a unique
user type (with some effort to map English plurals to their singular forms).

The primary intended use is via the ucalc script that prints out all of the
"readable" variants of a value. For example, "3 bytes" will only produce "3
byte", but "3 byte / sec" produces the original along with "180 byte / minute",
"10.55 kilobyte / hour", etc.

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.

The "mro" namespace provides several utilities for dealing with method
resolution order and method caching in general in Perl 5.9.5 and higher.
This module provides those interfaces for earlier versions of Perl (back to
5.6.0 anyways).

It is a harmless no-op to use this module on 5.9.5+. That is to say, code
which properly uses MRO::Compat will work unmodified on both older Perls and
5.9.5+.

If you're writing a piece of software that would like to use the parts of
5.9.5+'s mro:: interfaces that are supported here, and you want compatibility
with older Perls, this is the module for you.

Some parts of this code will work better and/or faster with Class::C3::XS
installed (which is an optional prereq of Class::C3, which is in turn a prereq
of this package), but it's not a requirement.

This module never exports any functions. All calls must be fully qualified
with the mro:: prefix.

The interface documentation here serves only as a quick reference of what the
function basically does, and what differences between MRO::Compat and 5.9.5+
One should look out for. The main docs in 5.9.5's mro are the real interface
docs, and contain a lot of other useful information.

Authors:
--------
Brandon L. Black,