DeskMenu is a root menu program which is activated by clicking the root
window. It is configured from a .deskmenurc file in your home directory.
DeskMenu is useful for window managers which do not provide a menu such as
Oroborus.
Rose::DB::Object is a base class for objects that encapsulate a
single row in a database table. It provides the following functions:
* Create a row in the database by saving a newly constructed object.
* Initialize an object by loading a row from the database.
* Update a row by saving a modified object back to the database.
* Delete a row from the database.
* Fetch an object referred to by a foreign key in the current object.
(i.e., "one to one" and "many to one" relationships.)
* Fetch multiple objects that refer to the current object, either directly
through foreign keys or indirectly through a mapping table. (i.e., "one
to many" and "many to many" relationships.)
* Load an object along with "foreign objects" that are related through any
of the supported relationship types.
Rose::DB is a wrapper and abstraction layer for DBI-related
functionality. A Rose::DB object "has a" DBI object; it is not a
subclass of DBI.
Tip: Are you looking for an object-relational mapper (ORM)? If so,
please see the Rose::DB::Object module. Rose::DB::Object is an ORM
that uses this module to manage its database connections. Rose::DB
alone is simply a data source abstraction layer; it is not an ORM.
Rose::Class is a generic base class for classes. It provides a
single class method (error), but may be expanded further in the
future.
A class that inherits from Rose::Class is not expected to allow
objects of that class to be instantiated, since the namespace for
class and object methods is shared. For example, it is common for
Rose::Object-derived classes to have error methods, but this would
conflict with the Rose::Class method of the same name.
The Rose::DateTime::* modules provide a few convenience functions
and objects for use with DateTime dates.
Rose::DateTime::Util contains a simple date parser and a slightly
customized date formatter.
Rose::DateTime::Parser encapsulates a date parser with an associated
default time zone.
This module (Rose::DateTime) exists mostly to provide a version
number for CPAN. See the individual modules for some actual
documentation.
This module provides a general-purpose clone function to make deep
copies of Perl data structures. It calls itself recursively to copy
nested hash, array, scalar and reference types, including tied
variables and objects.
The clone() function takes a scalar argument to copy. To duplicate
arrays or hashes, pass them in by reference:
The clone() function also accepts an optional second parameter that
can be used to limit the depth of the copy. If you pass a limit of
0, clone will return the same value you supplied; for a limit of
1, a shallow copy is constructed; for a limit of 2, two layers of
copying are done, and so on.
This module provides a simple routine for installing code into
packages without looking at typeglobs or thinking about warnings
or strictures.
It also doesn't muddy up UNIVERSAL.
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.
This module understands the formats used by PostgreSQL for its
DATE, TIME, TIMESTAMP, and INTERVAL data types. It can be used to
parse these formats in order to create DateTime or DateTime::Duration
objects, and it can take a DateTime or DateTime::Duration object
and produce a string representing it in a format accepted by
PostgreSQL.
A Time::Clock object is a twenty-four hour clock with nanosecond
precision and wrap-around. It is a clock only; it has absolutely
no concept of dates. Vagaries of date/time such as leap seconds
and daylight savings time are unsupported.
When a Time::Clock object hits 23:59:59.999999999 and at least one
more nanosecond is added, it will wrap around to 00:00:00.000000000.
This works in reverse when time is subtracted.
Time::Clock objects automatically stringify to a user-definable
format.