Class::ObjectTemplate::DB extends Class::ObjectTemplate in one
simple way: the undefined() method.
The author finds this useful when representing classes based on
objects stored in databases (hence the name of the module).
That way an object can be created, without triggering a DB lookup.
Later if data is accessed and it is not currently present in the object,
it can be retrieved on an as-need basis.
This module provides an API for loading and saving of simple configuration
file records. Entries in the configuration file are essentially key,value
pairs, with the key and values separated by a single equals symbol. The
key consists only of alphanumeric characters. There are three types of
values, scalar values can contain anything except newlines. Trailing
whitespace will be trimmed unless the value is surrounded in double
quotes.
From Date::Simple(3) man page:
Dates are complex enough without times and timezones. This module may be used to
create simple date objects. It handles:
Validation:
Reject 1999-02-29 but accept 2000-02-29.
Interval arithmetic:
How many days were between two given dates? What date comes N days after
today?
Day-of-week calculation:
What day of the week is a given date?
It does NOT deal with hours, minutes, seconds, and time zones.
Date::Business provides the functionality to perform simple date manipulations
quickly. Support for calendar date and business date math is provided.
Business dates are weekdays only. Adding 1 to a weekend returns Monday,
subtracting 1 returns Friday.
The difference in business days between Friday and the following
Monday (using the diffb function) is one business day. The
number of business days between Friday and the following
Monday (using the betweenb function) is zero.
DateTime::Astro implements functions used in astronomical calendars:
- Solar Longitude
- Solar Terms
- Lunar Longitude
- New Moons
... etc
This module is best used in environments where a C compiler and the MPFR
arbitrary precision math library is installed. It can fallback to using
Math::BigInt, but that would pretty much render it useless because of its speed
and loss of accuracy that may creep up while doing Perl to C struct conversions.
The DateTime::Event::Easter module returns Easter events for DateTime objects.
From a given datetime, it can tell you the previous, the following and the
closest Easter event. The 'is' method will tell you if the given DateTime is an
Easter Event.
Easter Events can be Palm Sunday, Maundy Thursday, Good Friday, Black Saturday
and Easter Sunday. If that's not enough, the module will also accept an offset
so you can get the date for Pentecost (49 days after Easter Sunday) by passing
49.
Declaring constants is very convenient for writing programs, but as
they're often inlined by Perl, retrieving their symbolic names can be
tricky. This is made worse with low level modules that use constants for
bit-twiddling.
Devel::Constants makes this much more manageable.
It silently wraps around the constant module, intercepting all constant
declarations. It builds a hash, associating the values to their names.
The names can then be retrieved as necessary.
The Perl 5 module Devel::Events::Objects provides an event generator
and a handler for Devel::Events, that facilitate leak checking.
There are two components of this module: Devel::Events::Generator::Objects,
and Devel::Events::Handler::ObjectTracker. The first one uses some
trickery to generate events for every object creation and destruction
in code loaded after it was loaded. The second one will listen on
these events, and track all currently living objects.
Perl's global destruction is a little tricky to deal with WRT finalizers
because it's not ordered and objects can sometimes disappear.
Writing defensive destructors is hard and annoying, and usually if global
destruction is happenning you only need the destructors that free up non
process local resources to actually execute.
For these constructors you can avoid the mess by simply bailing out if global
destruction is in effect.
This module provides an attribute wrapper around Getopt::Long. Instead of
declaring the options in a hash with references to the variables and subroutines
affected by the options, you can use the Getopt attribute on the variables and
subroutines directly.
As you can see from the Synopsis, the attribute takes an argument of the same
format as you would give as the hash key for Getopt::Long. See the Getopt::Long
manpage for details.