Free io pipe producer software for linux

IO::Pipe::Producer is a Perl module that provides two modules getSubroutineProducer and getSystemProducer.

SYNOPSIS

# Module which provides 2 methods: getSubroutineProducer
# and getSystemProducer. They take a subroutine reference
# (with associated arguments) and a system call
# respectively and return (blessed) handles on their
# streaming standard output and standard error output.


# EXAMPLES of usage

use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
$stdout_fh =
$obj->getSubroutineProducer($subroutine_reference,
@subroutine_parameters);

# OR

use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
($stdout_fh,$stderr_fh) =
$obj->getSubroutineProducer($subroutine_reference,
@subroutine_parameters);

# OR

use IO::Pipe::Producer;
$stdout_fh = new IO::Pipe::Producer($subroutine_reference,
@subroutine_parameters);

# OR

use IO::Pipe::Producer;
($stdout_fh,$stderr_fh) =
new IO::Pipe::Producer($subroutine_reference,
@subroutine_parameters);

# Then you can read the returned handles like any other
# file handle...

while()
{print "STDOUT From Producer: $_"}
while()
{print "STDERR From Producer: $_"}

# You can also do the same thing with system calls using
# the getSystemProducer subroutine. However, this feature
# is not accessible via the new constructor

use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
$stdout_fh =
$obj->getSystemProducer("echo "Hello World!"");

use IO::Pipe::Producer;
$obj = new IO::Pipe::Producer();
($stdout_fh,$stderr_fh) =
$obj->getSystemProducer("echo "Hello World!"");

# However, this is exactly the same as:

use IO::Pipe::Producer;
$stdout_fh = new Producer(sub{system(@_)},
"echo "Hello World!"");

# OR

use IO::Pipe::Producer;
($stdout_fh,$stderr_fh) =
new IO::Pipe::Producer(sub{system(@_)},
"echo "Hello World!"");

Pipepanic is a pipe connecting game using libSDL. It is playable on Linux PCs and the Sharp Zaurus. Connect as many different shaped pipes together as possible within the time given.

Comes with built-in help, is primarily mouse/stylus driven and can be played in different resolutions and orientations.

LiON Library is a full nonblocking, single thread library with an API that is portable and easy to use.
LiON Library has full network support, files, and pipes (for spawning children, or processes to communicate with). All types can also be rate (KB/s) limited, and full SSL support is included.
Main features:
- Nonblocking Networking.
- Nonblocking File I/O.
- Nonblocking pipe/system and fork commands for spawning helper programs.
- Event driven, event passback for all situations.
- SSL incorporated, with auto-detection.
- Portable (Already confirmed NetBSD, Solaris, Linux, OsX and Win32)
- Single process / thread library.
- Numerous Sample programs included.
- Support both in-library sleep/CPU-release, or in Application.
- Full buffering control, and flow control.
- CPS (KB/s) rate limits on _any_ I/O type. (Socket, File & Pipe)
- Adoptable foreign file-descriptors API.
- Clean API with documentation, although man-page comming.
- Direct, or event driven, failure modes supported.
- Exclusive File I/O locking optional, across all platforms.
- Internal compression optional.
- Very simple to use for line-by-line protocols, or binary chunk data transfers.
- Full UDP support
- Encrypted File IO support (blowfish, dependent on SSL)
- contrib/ sources include Directory listings library for all platforms.
- Python support! Using SWIG there now is an easy way to do async SSL in Python
- Timers! Callback timers in relative or absolute time. One-shot or repeat.
Enhancements:
- SSL connections could stall based on buffer size, so this has been fixed.
- Minor autoconf changes were made.
- Missing Win32 files were added to the dist-gzip file again.

Simple UDP proxy/pipe is an advanced UDP proxy/datapipe/packets forwarder and modifier with multiple functions.

Multiple clients allowed (you can connect many clients you want to this proxy), creation of ACP files (tcpdump capture files, just like a sniffer), packets forwarding (chat style, each packet is forwarded to all the other clients and server connected), packets injection (the tool opens a specific UDP port where you can send your customized packets which will be sent to the server), hexadecimal visualization and plugins support for the modification and visualization of the packets with some example plugins already included (Zdaemon huffman, Doom huffman, Half-life decoding and one for the replacement of the text strings).

Plugins (which work on both Windows and Linux) are very basic to create and use, just take a look at example_sudp.c for more informations.

xmmspipe is a plugin for XMMS that enables it to be controlled by sending strings to a named pipe (FIFO). When you enable the plugin, XMMS can be commanded by sending strings to $HOME/.xmms/inpipe, for example,
echo play_pause > ~/.xmms/inpipe
will cause XMMS to pause or play.
Since version 0.5.0, it is possible to setup an output pipe, and query XMMS for information. For example, sending "report title" to the input pipe will cause the current songs title to be printed on the output pipe.
Included is a demo program called "fade", that shows how to use the plugin to fade the current song and advance to the next one. It requires the output pipe to be be enabled (via the Config window).
The Infopipe plugin does output pipes a little differently.
When I first wrote this plugin, I didnt know about other programs that I couldve used to control XMMS with shell scripts, such as xmmsctrl or xmms-shell. However, Ive kept xmmspipe alive because pipes may be preferable in some situations:
The pipe automatically inherits the security features of the underlying filesystem (e.g. you could change its permissions so that only users of a particular group can control XMMS).
In many programming languages, writing to a pipe is easier than executing programs, making it easier to build programs to control XMMS.
The plugin can call internal XMMS functions which means it can have more functionality than programs relying on the xmms_remote_* functions alone. For example, XMMSPipe can load/save playlists.
Sometimes I think XMMS itself should just be an MP3-playing daemon that interfaces with the outside world exclusively through pipes (one for input, at least one for output). This would allow a lot more flexibility, e.g. the GUI could be arbitrary and playlists could be managed by an external program. (It would work in the same way gkrellm works with files in /proc.) Also, the code would be simpler because it only has to worry about reading various audio formats and playing them. It wouldnt have to deal with window managers, X, etc.
Enhancements:
- Added playlist_move command due to Graeme Yeo

Bio::Phylo::IO Perl module contains input and output of phylogenetic data.

SYNOPSIS

use Bio::Phylo::IO;

# parsing a tree from a newick string
my $tree_string = (((A,B),C),D);;
my $tree = Bio::Phylo::IO->parse(
-string => $tree_string,

# old parser, always adds node labels
-format => newick,
)->first;

# note: newick parsers return
# Bio::Phylo::Forest! Call
# ->first to retrieve the first
# tree of the forest.

# prints Bio::Phylo::Forest::Tree
print ref $tree, "n";

# parsing a table
my $table_string = qq(A,1,2|B,1,2|C,2,2|D,2,1);
my $matrix = Bio::Phylo::IO->parse(
-string => $table_string,
-format => table,

# Data type, see Bio::Phylo::Parsers::Table
-type => STANDARD,

# field separator
-fieldsep => ,,

# line separator
-linesep => |
);

# prints Bio::Phylo::Matrices::Matrix
print ref $matrix, "n";

# parsing a list of taxa
my $taxa_string = A:B:C:D;
my $taxa = Bio::Phylo::IO->parse(
-string => $taxa_string,
-format => taxlist,
-fieldsep => :
);

# prints Bio::Phylo::Taxa
print ref $taxa, "n";

# matches taxon names in tree to $taxa object
$tree->cross_reference($taxa);

# likewise for matrix
$matrix->cross_reference($taxa);

print Bio::Phylo::IO->unparse(

# pass the tree object,
# crossreferenced to taxa, which
# are crossreferenced to the matrix
-phylo => $tree,
-format => pagel
);

# prints a pagel data file:
#4 2
#A,n1,0.000000,1,2
#B,n1,0.000000,1,2
#n1,n2,0.000000
#C,n2,0.000000,2,2
#n2,n3,0.000000
#D,n3,0.000000,2,1

IO::Prompt is a Perl module to interactively prompt for user input.

SYNOPSIS

use IO::Prompt;
while( prompt "next: " ) {
print "You said $_n";
}

By default, this module exports a single function prompt. It prompts the user to enter some input, and returns an object that represents the user input.

You may specify various flags to the function to affect its behaviour; most notably, it defaults to automatically chomp the input, unless the -line flag is specified.

Two other functions are exported at request: hand_print, which simulates hand-typing to the console; and get_input, which is the lower-level function that actually prompts the user for a suitable input.

Note that this is an interim re-release. A full release with better documentation will follow in the near future. Meanwhile, please consult the examples directory from this modules CPAN distribution to better understand how to make use of this module.