This package provides some low-level utilities to use for package
development. It currently provides managers for multiple package
specific options and registries, vignette, unit test and bibtex
related utilities. It serves as a base package for packages like
NMF, RcppOctave, doRNG, and as an incubator package for other general
purposes utilities, that will eventually be packaged separately.
It is still under heavy development and changes in the interface(s)
are more than likely to happen.
Tie::Array::Sorted represents an ordinary array, which is kept sorted.
All pushes and unshifts cause the elements in question to be inserted in
the appropriate location to maintain order.
Direct stores ($a[10] = "wibble") effectively splice out the original
value and insert the new element. It's not clear why you'd want to use
direct stores like that, but this module does the right thing if you do.
This module replaces the standard localtime and gmtime functions with
implementations that return objects. It does so in a backwards
compatible manner, so that using localtime/gmtime in the way documented
in perlfunc will still return what you expect.
The module actually implements most of an interface described by Larry
Wall on the perl5-porters mailing list here:
http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2000-01/msg00241.html
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'
The autodie pragma provides a convenient way to replace functions
that normally return false on failure with equivalents that throw
an exception on failure.
The autodie pragma has lexical scope, meaning that functions and
subroutines altered with autodie will only change their behaviour
until the end of the enclosing block, file, or eval.
If system is specified as an argument to autodie, then it uses
IPC::System::Simple to do the heavy lifting. See the description
of that module for more information.
This is a parser to replace UBB style tags with their html equivalents.
It does not simply do some regex calls, but is complete stack based
parse engine. This ensures that all tags are properly nested, if not,
extra tags are added to maintain the nesting. This parser should only
produce xhtml 1.0 compliant code. All tags are validated and so are all
their attributes. It should be easy to extend this parser with your own
tags.
Blitz is a PHP templating engine with two main features:
Fast. Blitz is written in C and built as PHP-extension which makes it one of
the fastest template engines (you may see the benchmarks section below)
Clear. Blitz has quite simple and clear syntax and makes developer to build
compact and easy-to-read-and-support code even for applications with very
complex presentation logic
This library is a collection of classes intended to be used to help
improve the performance of GNUstep and Cocoa applications. The scope
of the library is therefore -
1. Subclasses of standard Cocoa classes which are optimised for
particular uses.
2. Classes to perform tasks which can improve application performance
by mechanisms not covered by existing classes.
3. Classes to monitor/analyse performance issues so you can tell what
needs to be optimised.
LICENSE: LGPL3 or later
SimPy (= Simulation in Python) is an object-oriented, process-based discrete-
event simulation language based on standard Python and released under the GNU
GPL. It provides the modeler with components of a simulation model including
processes, for active components like customers, messages, and vehicles, and
resources, for passive components that form limited capacity congestion points
like servers, checkout counters, and tunnels. It also provides monitor variables
to aid in gathering statistics. Random variates are provided by the standard
Python random module.
PEAK-Rules is a highly-extensible framework for creating and using
generic functions, from the very simple to the very complex. Out of
the box, it supports multiple-dispatch on positional arguments using
tuples of types, full predicate dispatch using strings containing
Python expressions, and CLOS-like method combining. (But the framework
allows you to mix and match dispatch engines and custom method
combinations, if you need or want to.)