Converts back and forth between a nested hash structure and a flat hash of
delimited key-value pairs. Useful for protocols that only support
key-value pairs (such as CGI and DBMs).
Hash::Merge::Simple will recursively merge two or more hashes and
return the result as a new hash reference. The merge function will
descend and merge hashes that exist under the same node in both the
left and right hash, but doesn't attempt to combine arrays, objects,
scalars, or anything else. The rightmost hash also takes precedence,
replacing whatever was in the left hash if a conflict occurs.
This code was pretty much taken straight from Catalyst::Utils, and
modified to handle more than 2 hashes at the same time.
Store multiple values per key.
Under older perls this module provides a drop in compatible api to
Hash::Util::FieldHash using perltie. When Hash::Util::FieldHash is available
it will use that instead.
This way code requiring field hashes can benefit from fast, robust field
hashes on Perl 5.10 and newer, but still run on older perls that don't ship
with that module.
This module provides a pure perl implementation of the interface described
in Heap::Simple. Look there for a description.
Provides an object-oriented interface to either the POSIX mmap() or
Win32 equivalent APIs to memory map a file into a process's address
space for general memory access. IPC::Mmap provides only a minimal
interface without the additional overhead of tie'd variables or
locking enforced in other modules (e.g., Sys::Mmap, Win32::MMF); hence,
the application is responsible for performing read()'s and write()'s
on the IPC::Mmap object, and calling any needed lock() and unlock()
methods, as required by concurrent processes.
Memory mapped files provide an alternate shared memory mechanism for
multiple processes. The technique maps the OS's file system buffers
for a given file into each mmap()'ing process's virtual memory space,
thereby permitting each process to essentially share the same physical
memory. Refer to the excellent "Advanced Programming in the UNIX
Environment", Stevens et al., Addison-Wesley Publisher for a detailed
reference on the POSIX implementation. IPC::Mmap provides OS-agnostic
wrappers for both the POSIX and Win32 memory mapped file capabilities.
IPC::Open3::Simple aims at making it very easy to start a shell command,
eventually feed its stdin with some data, then retrieve its stdout and stderr
separately.
When you want to run a shell command and parse its stdout/stderr or feed its
stdin, you often end up using IPC::Run, IPC::Cmd or IPC::Open3 with your own
parsing code, and end up writing more code than you intended. IPC::Open3::Simple
is about removing this overhead and making IPC::Open3 easier to use.
IPC::Open3::Simple calls IPC::Open3 and redirects stdin, stdout and stderr to
some function references passed in argument to the constructor. It does a select
on the input/output filehandles returned by IPC::Open3 and dispatches their
content to and from those functions.
a class for executing remote perl code over an SSH link
This module provides an XS implementation of the interface described in
Heap::Simple. Look there for a description.
IPC::Run and IPC::Run3 are both very upset when you try to use them
under environments where you have STDOUT and/or STDERR tied to something
else, such as under fastcgi.
The module adds safe-guarding code when you call IPC::Run or IPC::Run3
under such environment to make sure it always works.
If you intend to release your code to work under normal envionrment as
well as under fastcgi, simply use this module *after* the "IPC" modules
are loaded in your code.