This module provides a convenient interface to timing functions
through tied scalars.
This package contains the following perl5 modules:
* Time::CTime - ctime, strftime, and asctime
* Time::JulianDay - Julian calendar manipulations
* Time::ParseDate - reverses strftime and also understands relative times
* Time::Timezone - miscellaneous timezone manipulations routines
* Time::DaysInMonth - simply report the number of days in a month
The Perl garbage collector uses simple reference counting during the normal
execution of a program. This means that cycles or unweakened references in other
parts of code can keep an object around for longer than intended. To help avoid
this problem, the reference count of a new object from its class constructor
ought to be 1. This way, the caller can know the object will be properly
DESTROYed when it drops all of its references to it.
Test::Refcount provides two test functions to help ensure this property holds
for an object class, so as to be polite to its callers.
If the assertion fails; that is, if the actual reference count is different to
what was expected, a trace of references to the object can be printed, if Marc
Lehmann's Devel::FindRef module is installed. This may assist the developer in
finding where the references are.
Load your commonly-used modules in a single import
Devel::TraceFuncs provides utilities to trace the
execution of a program. It can print traces that look
something like:
+-> global: '0'
| +-> main::fo(4, 5) (in ./t.pm:32): 'now then'
| | +-> main::fp(4, 5) (in ./t.pm:19)
| | | +-> main::fq() (in ./t.pm:13)
| | | | que pee doll (in ./t.pm:8)
| | | +-< main::fq() (in ./t.pm:13)
| | | cee dee (in ./t.pm:14)
| | +-< main::fp(4, 5) (in ./t.pm:19)
| | ha
| | hs (in ./t.pm:20)
| +-< main::fo(4, 5) (in ./t.pm:32): 'now then'
| done (in ./t.pm:34)
+-< global: '0'
This module allows you to compose Test::More tests from roles.
It is inspired by the excellent Test::Routine module,
but uses Moo instead of Moose.
This gives most of the benefits
without the need for Moose as a test dependency.
Tree::RedBlack is a perl implementation of the Red/Black tree algorithm found in
the book "Algorithms", by Cormen, Leiserson & Rivest (more commonly known as
"CLR" or "The White Book"). A Red/Black tree is a binary tree which remains
"balanced"- that is, the longest length from root to a node is at most one more
than the shortest such length. It is fairly efficient; no operation takes more
than O(lg(n)) time.
A Tree::RedBlack object supports the following methods: new(), root(), cmp(&),
insert($, $), delete($), find($), node($), min() and max().
Test::SharedFork is utility module for Test::Builder.
This module makes forking test!
This module merges test count with parent process & child process.
** If you are unfamiliar with testing read Test::Tutorial first! **
This is a simple, basic module for checking whether a class is a Singleton. A
Singleton describes an object class that can have only one instance in any
system. An example of a Singleton might be a print spooler or system registry,
or any kind of central dispatcher.
For a description and discussion of the Singleton class, see "Design Patterns",
Gamma et al, Addison-Wesley, 1995, ISBN 0-201-63361-2.
This module implements a trie data structure. The term "trie" comes from the
word retrieval, but is generally pronounced like "try". A trie is a tree
structure (or directed acyclic graph), the nodes of which represent letters
in a word. For example, the final lookup for the word 'bob' would look
something like $ref->{'b'}{'o'}{'b'}{'00'} (the 00 being an end marker).
Only nodes which would represent words in the trie exist, making the structure
slightly smaller than a hash of the same data set.
The advantages of the trie over other data storage methods is that lookup times
are O(1) WRT the size of the index. For sparse data sets, it is probably not as
efficient as performing a binary search on a sorted list, and for small files,
it has a lot of overhead. The main advantage (at least from my perspective) is
that it provides a relatively cheap method for finding a list of words in a
large, dense data set which begin with a certain string.