The "CPANPLUS" library is an API to the "CPAN" mirrors and a collection of
interactive shells, command line programs, daemons, etc, that use this API.
A module that caches a data structure against a filename, statting the
file to determine whether it has changed and needs to be re-parsed.
You supply a routine to generate the data structure given the filename.
This module is recommended for files which change infrequently but
are read often, especially if they are expensive to parse.
This approach has the advantage over lazy caching that multiple
processes holding a cache will all update at the same time so you
will not get inconsistent results if you request data from different
processes.
The module itself is simply a factory for various backend modules.
The distribution includes backends for in-memory caching or file
caching using Storable, plus an adaptor to use any modules offering
the Cache or Cache::Cache interfaces as the cache implementation.
Data structures are automatically serialised/deserialised by the
backend modules if they are being persisted somewhere other than
in memory (e.g. on the filesystem).
The Perl Cache package provides Cache::Cache, a generic interface for
creating persistent data stores. This interface is implemented by the
Cache::MemoryCache, Cache::SharedMemoryCache, Cache::FileCache,
Cache::SizeAwareFileCache, Cache::SizeAwareMemoryCache, and
Cache::SizeAwareSharedMemoryCache classes. This work replaces
File::Cache and IPC::Cache.
-Anton
<tobez@FreeBSD.org>
A shared memory cache through an mmap'ed file. It's core is written in
C for performance. It uses fcntl locking to ensure multiple processes
can safely access the cache at the same time. It uses a basic LRU
algorithm to keep the most used entries in the cache.
A simple, fast implementation of an in-memory LRU cache in pure perl with
the maximum number of entries to be stored within the cache object.
The Cache modules are designed to assist a developer in persisting
data for a specified period of time. Often these modules are used
in web applications to store data locally to save repeated and
redundant expensive calls to remote machines or databases.
Cairo::GObject registers Cairo's types (Cairo::Context, Cairo::Surface, etc.)
with Glib's type systems so that they can be used normally in signals and
properties.
When programming with callbacks in perl, you create anonymous functions with
sub { ... }. These functions are especially useful because when they are called
they will preserve their surrounding lexical environment. Sometimes people
call these anonymous functions that reference variables in their surrounding
lexical scope "closures". Whatever you call them, they are essential for
convenient and efficient asynchronous programming.
For many applications we really like straightforward callback style. The goal
of Callback::Frame is to simplify the management of dynamic environments while
leaving callback style alone.
Capture::Tiny provides a simple, portable way to capture anything sent to
STDOUT or STDERR, regardless of whether it comes from Perl, from XS code or
from an external program. Optionally, output can be teed so that it is captured
while being passed through to the original handles.
This module provides a shared cache, using a memory mapped file. Very useful
for mod_perl applications. If routines are provided which interact with the
underlying data, access to the cache is completely transparent, and the module
handles all the details of refreshing cache contents, and updating underlying
data, if necessary.