Free poe component enc flac 1.01 software for linux

PoJoe Component Libraries project is a set of Java POJO components, originally developed for OSMQ. Developers have found these components useful in building robust enterprise applications.
Of note are: a FIFO queue that utilizes memory until a size threshold is reached, paging overflow elements to a disk cache; a dynamic discovery mechanism for locating remote processes by name over an IP network, eliminating the need to identify a remote service with a specific host computer; and a set of peer-to-peer async message components that support n concurrent message publishers for each named subscriber.
Enhancements:
- Minor enhancements and bugfixes, and changing the license from GNU Lesser to Apache 2.0.

POE::Component::OSCAR is a POE component for the Net::OSCAR module.

SYNOPSIS

use POE qw(Component::OSCAR);

[ ... POE set up ... ]

sub _start { # start an OSCAR session $oscar = POE::Component::OSCAR->new();
# start an OSCAR session with automatic throttling of new connections
# to prevent being banned by the server
$oscar = POE::Component::OSCAR->new( throttle => 4 );

# set up the "im_in" callback to call your state, "im_in_state"
$oscar->set_callback( im_in => im_in_state);

# its good to detect errors if you dont want to get banned
$oscar->set_callback( error => error_state );
$oscar->set_callback( admin_error => admin_erro_stater );
$oscar->set_callback( rate_alert => rate_alert_state );

# sign on
$oscar->signon( screenname => $MY_SCREENNAME, password => $MY_PASSWORD );
}
sub im_in_state { my ($nothing, $args) = @_[ARG0..$#_]; my ($object, $who, $what, $away) = @$args;
print "Got $what from $whon";
}

POE::Component::Growl provides a Growl notification dispatcher for POE.

POE::Component::Growl provides a facility for notifying events through Growl using the Mac::Growl module as back-end. Integration with POEs architecture allows easy, non-blocking notifications.

Multiple notifiers can be spawned within the same POE application with multiple default options..


A program must spawn at least one POE::Component::Growl instance before it can perform Growl notifications. Each instance registers itself with Growl itself by passing a few parameters to it, and a reference to the object is returned for optional manual handling (see notify method below).

The following parameters can be passed to the spawn constructor (AppName and Notifications are required).

AppName
This must contain the name of the application. It may be a free string as it isnt required to match any existing file name; its purpose is only to let Growl define user preferences for each application.

Notifications
This must be an arrayref containing the list of possible notifications from our application. These names will be displayed in Growl preference pane to let users customize options for each notification.

DefaultNotificatons
(Optional) This parameter can contain an arrayref with the list of notifications to enable by default. If DefaultNotifications isnt provided, POE::Component::Growl will enable all available notifications, otherwise the user will have to manually enable those which arent included here.

Alias
(Optional) This parameter will be used to set POEs internal session alias. This is useful to post events and is also very important if you instantiate multiple notifiers. If left empty, the alias will be set to "Growl".

IconOfApp
(Optional) This parameter can contain the name of an application whose icon is to use by default.

POE::Component::Generic is a POE component that provides non-blocking access to a blocking object.

SYNOPSIS

use POE::Component::Generic;

my $telnet = POE::Component::Generic->spawn(

# required; main object is of this class
package => Net::Telnet,

# optional; Options passed to Net::Telnet->new()
object_options => [ ],

# optional; You can use $poco->session_id() instead
alias => telnet,
# optional; 1 to turn on debugging
debug => 1,
# optional; 1 to see the childs STDERR
verbose => 1,

# optional; Options passed to the internal session
options => { trace => 1 },

# optional; describe package signatures
packages => {
Net::Telnet => {
# Methods that require coderefs, and keep them after they
# return.

# The first arg is converted to a coderef
postbacks => { option_callback=>0 }
},
Other::Package => {
# only these methods are exposed
methods => [ qw( one two ) ],

# Methods that require coderefs, but dont keep them
# after they return
callbacks => [ qw( two ) ]
}
}
);

# Start your POE session, then...

$telnet->open( { event => result }, "rainmaker.wunderground.com");
# result state
sub result {
my ($kernel, $ref, $result) = @_[KERNEL, ARG0, ARG1];

if( $ref->{error} ) {
die join( , @{ $ref->{error} ) . "n";
}
print "connected: $resultn";
}


# Setup a postback
$telnet->option_callback( {}, "option_back" );

# option_back state
sub option_back {
my( $obj, $option, $is_remote,
$is_enabled, $was_enabled, $buf_position) = @_[ARG0..$#_];
# See L for a discussion of the above.

# NOTE: Callbacks and postbacks cant currently receive objects.
}

# Use a callback
# Pretend that $other was created as a proxy to an Other::Package object
$other->two( {}, sub { warn "I was called..." } );

my $code = $session->postback( "my_state" );
$other->two( {}, $code );

POE::Component::Generic is a POE component that provides a non-blocking wrapper around any object. It works by forking a child process with POE::Wheel::Run and creating the object in the child process. Method calls are then serialised and sent via STDIN to the child to be handled. Return values are posted back to your session via STDOUT. This means that all method arguments and return values must survive serialisation. If you need to pass coderefs, use "callbacks", "postbacks" or "factories".
Method calls are wrapped in eval in the child process so that errors may be propagated back to your session. See "OUTPUT".

Output to STDERR in the child, that is from your object, is shown only if debug or verbose is set.

STDOUT in the child, that is from your object, is redirected to STDERR and will be shown in the same circomstances.

POE::Component::Client::FTP is a Perl module that implements an FTP client POE Component.

SYNOPSIS

use POE::Component::Client::FTP;

POE::Component::Client::FTP->spawn ( Alias => ftp, Username => test, Password => test, RemoteAddr => localhost, Events => [ qw( authenticated put_connected put_error put_closed get_connected get_data get_done size ) ] );

# we are authenticated sub authenticated { $poe_kernel->post(ftp, command, args); }
# data connection is ready for data sub put_connected { my ($status, $line, $param) = @_[ARG0..ARG3];
open FILE, "/etc/passwd" or die $!;
$poe_kernel->post(ftp, put_data, $_) while ( );
close FILE;
$poe_kernel->post(ftp, put_close);
}
# something bad happened sub put_error { my ($error, $param) = @_[ARG0,ARG1];
warn "ERROR: $error occured while trying to STOR $param";
}
# data connection closed sub put_closed { my ($param) = @_[ARG0]; }
# file on the way... sub get_connected { my ($filename) = @_[ARG0]; }
# getting data from the file... sub get_data { my ($data, $filename) = @_[ARG0,ARG1];
}
# and its done sub get_done { my ($filename) = @_[ARG0]; }
# response to a size command sub size { my ($code, $size, $filename) = @_[ARG0,ARG1,ARG2];
print "$filename was $size";
}
$poe_kernel->run();

POE::Component::Client::TCPMulti is a high performance client TCP library.

SYNOPSIS

# Short Usage
POE::Component::Client::TCPMulti->create
( InputEvent => sub {
printf "%s:%d: %s",
$_[CHEAP]->ADDR, $_[CHEAP]->PORT, $_[ARG0];
},
SuccessEvent => sub {
printf "%s:%d: Connection Recieved",
$_[CHEAP]->ADDR, $_[CHEAP]->PORT;
$_[KERNEL]->yield( send => "" );
},
inline_states => {
_start => sub {
$_[KERNEL]->yield( connect => "127.0.0.1", $_ )
for 1..1024;
},
},
InputTimeout => 15,
);

# Longer Usage
POE::Component::Client::TCPMulti->create
( InputEvent => sub {
$_[KERNEL]->yield(send => $_[CHEAP]->ID, "Some Stuff");
},

Initialize => sub {
$_[CHEAP]->input_filter
( "POE::Filter::Block", BlockSize => 4);
},
ErrorEvent => &ErrorHandle,
Disconnected => &ErrorHandle,
TimeoutEvent => &TimeoutHandle,
FailureEvent => &FailureHandle,
SuccessEvent => sub {
$_[CHEAP]->filter("POE::Filter::Line");

# Set timeout for this connection to 350 seconds.
$_[CHEAP]->timeout(350);

# This state is part of the component interface
$_[KERNEL]->yield(send => $_[CHEAP]->ID, "Some Data");
},

Domain => AF_INET, # Optional

Alias => "MySession", # Optional
InputTimeout => 360, # Seconds, Optional
ConnectTimeout => 30, # Seconds, Optional
Timeout => 30, # Seconds, Optional
Filter => "POE::Filter::Something", # Optional

inline_states => {
_start => sub {
$_[KERNEL]->yield(connect => q(127.0.0.1), 25);
# _start isnt needed if you use an alias.
},
},

args => $Session_Args, # Optional
object_states => $Object_States, # Optional
package_states => $Package_States, # Optional
);

# This should be done from within a state in the TCPMulti
# Session. Its purpose is to allow prepropigation of the
# connection heap as well as connection specific timeout
# Settings.
POE::Component::Client::TCPMulti->connect
( RemoteAddress => "127.0.0.1",
RemotePort => 25,
BindAddress => "127.0.0.1", # Optional
BindPort => 0, # Optional
ConnectTimeout => 50, # Connect only.
InputTimeout => 300, # Input only.
Heap => %Propigation );

POE::Component::Client::TCPMulti is a very lightweight, highly optimized component designed for large numbers of simultanious outgoing connections. The major advantage to this module over POE::Component::Client::TCP is that it runs in a single session, reguardless of the number of outgoing simultanious connections. I have found this in fact to use considerable less overhead than POE::Component::Client::TCP in high traffic. The disadvantage lies mearly in the API complexity over POE::Component::Client::TCP.

It is in fact due to this added API complexity that I decided to create a seperate module, rather than altering POE::Component::Client::TCP [ or coaxing Rocco to let me ]. POE::Component::Client::TCP is a great module and this is not designed to completely replace it. It is however designed as a solution for extremely high traffic situations when the overhead of an individual session for each outgoing connection is not appropriate for the added simplicity in the API. Especially considering that this API is not really *that* much more complex.

POE::Component::Client::AirTunes is a Perl module with stream music to Airport Express.

SYNOPSIS

use POE qw( Component::Client::AirTunes );

POE::Component::Client::AirTunes->new(
host => $ip,
alias => "airtunes",
events => {
connected => connected,
error => error,
done => done,
},
);

$kernel->post(airtunes => volume => 100);
$kernel->post(airtunes => play => "/path/to/foobar.m4a");
$kernel->post(airtunes => stop);

POE::Component::Client::AirTunes is a POE component to stream music files to your Airport Express. This module is a frontend for a command line Airport Express player raop_play, which is included in Airport Express Client, availabe at http://raop-play.sourceforge.net.

See t/01_airtunes.t for more example. This module is ALPHA software and its API might change in the future.