view release on metacpan or search on metacpan
lib/Text/ZPL.pm view on Meta::CPAN
=head2 decode_zpl
Given a string of C<ZPL>-encoded text, returns an appropriate Perl C<HASH>; an
exception is thrown if invalid input is encountered.
(See L<Text::ZPL::Stream> for a streaming interface.)
=head2 encode_zpl
Given a Perl C<HASH>, returns an appropriate C<ZPL>-encoded text string; an
exception is thrown if the data given cannot be represented in C<ZPL> (see
view release on metacpan or search on metacpan
lib/Thrall/Server.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.url_scheme' => $self->{ssl} ? 'https' : 'http',
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => $self->{is_multithread},
'psgi.multiprocess' => $self->{is_multiprocess},
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
'psgix.input.buffered' => Plack::Util::TRUE,
'psgix.io' => $conn,
'psgix.harakiri' => Plack::Util::TRUE,
};
view release on metacpan or search on metacpan
t/resolveit view on Meta::CPAN
);
isa_ok( $resolve,'Thread::Pool::Resolve', 'check object type' );
my @thread;
push( @thread,threads->new( \&bythread ) ) foreach 1..10;
$_->join foreach @thread;
$resolve = undef; # needed to finalize streaming in time
ok( check( $resolved,$filtered ), 'check result different threads' );
diag( "Test resolving from Thread::Queue ($optimize)" );
@shared = (@array,undef);
my $queue = bless \@shared,'Thread::Queue';
view release on metacpan or search on metacpan
lib/Thread/Pool.pm view on Meta::CPAN
die "Cannot stream and monitor at the same time"
if exists $self->{ 'stream'};
# Make sure we have a real coderef for the pre and the monitoring routine
# Create a monitored belt
# Set the streaming routine that sends to the monitor
$self->_makecoderef( caller().'::',qw(pre monitor post checkpoint) );
$self->{'monitor_belt'} = Thread::Conveyor::Monitored->new(
{
optimize => $self->{'optimize'},
lib/Thread/Pool.pm view on Meta::CPAN
my $self = shift;
die "Cannot submit jobs on a pool that has been shut down"
if $self->{'shutdown'};
my $belt = $self->{'belt'};
# If we're streaming
# Die now if an individual jobid requested
# Put in box with a jobid obtained on the fly
if ($self->{'stream'}) {
die "Cannot return individual results when streaming"
if defined( wantarray );
$belt->put( $self->_jobid, \@_ );
# Elseif we want a jobid
# Obtain a jobid
lib/Thread/Pool.pm view on Meta::CPAN
} elsif (defined( wantarray )) {
my $jobid = $self->_jobid;
$belt->put( $jobid, \@_ );
return $jobid;
# Else (not streaming and not interested in the result)
# Put in box without a jobid
} else {
$belt->put( \@_ )
}
lib/Thread/Pool.pm view on Meta::CPAN
while (my ($jobid) = $belt->peek_dontwait) {
last if $jobid;
$belt->take;
}
# If we were streaming
# Obtain local copy of stuff we need
if (my $stream = $self->{'stream'}) {
my ($streamid,$jobid,$result) = @$self{qw(streamid jobid result)};
lib/Thread/Pool.pm view on Meta::CPAN
# For all the results that still need to be streamd
# Die if there is no result (_should_ be there by now)
# Call the "stream" routine with this result
# Delete the result from the hash
# Set the stream ID for any further streaming later
for (my $i = $$streamid; $i < $last; $i++) {
die "Cannot find result for streaming job $i"
unless exists( $result->{$i} );
$stream->( @extra,Thread::Serialize::thaw( $result->{$i} ) );
delete( $result->{$i} );
}
$$streamid = $last;
lib/Thread/Pool.pm view on Meta::CPAN
or:
stream => sub {print "anonymous sub called in order of submit\n"},
The "stream" field specifies the subroutine to be executed for streaming the
results of the "do" routine. If specified, the "stream" routine is called
once for the result of each "do" subroutine, but in the order in which the
L<job>s were submitted rather than in the order in which the result were
obtained (which is by the very nature of threads, indeterminate).
lib/Thread/Pool.pm view on Meta::CPAN
1..N the values that were returned by the "do" subroutine
The "monitor" routine is executed in its own thread. This means that all
results have to be passed between threads, and therefore be frozen and thawed
with L<Storable>. If you can handle the streaming from different threads,
it is probably wiser to use the "stream" routine feature.
=item pre_post_monitor_only
pre_post_monitor_only => 1, # default 0
lib/Thread/Pool.pm view on Meta::CPAN
=head2 jobid
$jobid = Thread::Pool->jobid;
The "jobid" class method only makes sense within the "do" subroutine in
streaming mode. It returns the job ID value of the current job. This can
be used connection with the L<dont_set_result> and the L<set_result> methods
to have another thread set the result of the current job.
=head2 dont_set_result
view release on metacpan or search on metacpan
bench/big_test_data view on Meta::CPAN
streaks
stream
streamed
streamer
streamers
streaming
streamline
streamlined
streamliner
streamlines
streamlining
view release on metacpan or search on metacpan
Revision history for Tie-Handle-TtyRec
0.04 2012-03-06
allow streaming to named pipes (Jesse Luehrs)
allow appending (Jesse Luehrs)
fix error message (Jesse Luehrs)
allow syswrite to work on these handles (Jesse Luehrs)
0.03 Sun Jun 14 14:59:00 2009
view release on metacpan or search on metacpan
lib/Tie/Array/DBD.pm view on Meta::CPAN
=item *
C<Storable> does not support persistence of perl types C<IO>, C<REGEXP>,
C<CODE>, C<FORMAT>, and C<GLOB>. Future extensions might implement some
alternative streaming modules, like C<Data::Dump::Streamer> or use mixin
approaches that enable you to fit in your own.
=item *
Note that neither DBD::CSV nor DBD::Unify support C<AutoCommit>.
lib/Tie/Array/DBD.pm view on Meta::CPAN
a database and restoring that. It will not be fool proof.
=item Mixins
Maybe: implement a feature that would enable plugins or mixins to do the
streaming or preservation of other data attributes.
=back
=head1 AUTHOR
view release on metacpan or search on metacpan
boost_1_47/boost/date_time/compiler_config.hpp view on Meta::CPAN
using stlport::use_facet;
}
#endif
// workaround for errors associated with output for date classes
// modifications and input streaming for time classes.
// Compilers affected are:
// gcc295, msvc (neither with STLPort), any borland
//
#if (((defined(__GNUC__) && (__GNUC__ < 3)) || \
(defined(_MSC_VER) && (_MSC_VER < 1300)) ) && \
view release on metacpan or search on metacpan
lib/Titanium.pm view on Meta::CPAN
$c->session(); # A CGI::Session object
$c->check_rm; # Form validation with Data::FormValidator
$c->cfg('root_uri'); # Config file access (YAML, Perl or INI formats)
$c->fill_form; # Form filling with HTML::FillInForm
$c->error( title => '..', msg => '..' ); # Easy error page generation
$c->stream_file($file); # file streaming
$c->log; # A Log::Dispatch object
=head2 Development and Testing
Easily setup the project skeleton using the bundled L<cgiapp-starter> script.
view release on metacpan or search on metacpan
PNG/libpng/contrib/gregbook/README view on Meta::CPAN
Chapters 13, 14 and 15 of "PNG: The Definitive Guide" discuss three free,
cross-platform demo programs that show how to use the libpng reference
library: rpng, rpng2 and wpng. rpng and rpng2 are viewers; the first is
a very simple example that that shows how a standard file-viewer might use
libpng, while the second is designed to process streaming data and shows
how a web browser might be written. wpng is a simple command-line program
that reads binary PGM and PPM files (the ``raw'' grayscale and RGB subsets
of PBMPLUS/NetPBM) and converts them to PNG.
The source code for all three demo programs currently compiles under
view release on metacpan or search on metacpan
t/anyevent_extensions.t view on Meta::CPAN
]);
}
},
],
[
'coderef streaming',
sub {
my $cb = shift;
my $res = $cb->(GET "http://127.0.0.1/?name=miyagawa");
is $res->code, 200;
is $res->header('content_type'), 'text/plain';
view release on metacpan or search on metacpan
lib/Twiggy.pm view on Meta::CPAN
=over 4
=item PSGI
Can run any PSGI applications. Fully supports I<psgi.nonblocking> and
I<psgi.streaming> interfaces.
=item AnyEvent
This server uses AnyEvent and runs in a non-blocking event loop, so
it's best to run event-driven web applications that runs I/O bound
jobs or delayed responses such as long-poll, WebSocket or streaming
content (server push).
This software used to be called Plack::Server::AnyEvent but was
renamed to Twiggy.