Next refresh should show more results. ( run in 4.449 )
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
"Modern::Perl" => 0,
"Capture::Tiny" => 0,
"Clone" => 0,
"JSON" => 0,
"DBI" => 0,
"Geo::GDAL" => 2.01, # to use streaming objects
"HTTP::Date" => 0,
"File::MkTemp" => 0,
"Data::Dumper" => 0,
"XML::LibXML::PrettyPrint" => 0, # for debugging
"Geo::OGC::Service" => 0.09,
view release on metacpan or search on metacpan
lib/Geo/OGC/Service.pm view on Meta::CPAN
=head3 call
This method is called internally by the method to_app of
Plack::Component. The method fails unless this module
is running in a psgi.streaming environment. Otherwise,
it returns a subroutine, which calls the respond method.
=cut
sub call {
my ($self, $env) = @_;
if (! $env->{'psgi.streaming'}) { # after Lyra-Core/lib/Lyra/Trait/Async/PsgiApp.pm
return [ 500, ["Content-Type" => "text/plain"], ["Internal Server Error (Server Implementation Mismatch)"] ];
}
return sub {
my $responder = shift;
$self->respond($responder, $env);
view release on metacpan or search on metacpan
lib/Gepok.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.url_scheme' => $is_ssl ? 'https' : 'http',
'psgi.run_once' => Plack::Util::FALSE,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
'psgix.input.buffered' => Plack::Util::TRUE,
'psgix.io' => $sock,
'psgix.input.buffered' => Plack::Util::TRUE,
'psgix.harakiri' => Plack::Util::TRUE,
view release on metacpan or search on metacpan
lib/Gerrit/Client.pm view on Meta::CPAN
},
);
};
# Unfortunately, we have no idea how long it takes between starting the
# stream-events command and when the streaming of events begins, so if
# we query straight away, we could miss some changes which arrive while
# stream-events is e.g. still in ssh negotiation.
# Therefore, introduce this arbitrary delay between when we start
# stream-events and when we'll perform a query.
my $query_timer;
view release on metacpan or search on metacpan
lib/Getopt/Yath/Tutorial.pm view on Meta::CPAN
option use_stream => (
type => 'Bool',
alt => ['stream'], # --stream also works
alt_no => ['TAP'], # --TAP is equivalent to --no-use-stream
description => 'Use streaming format instead of TAP',
);
=head2 prefix
Adds a prefix to the option name. Especially useful in option groups:
view release on metacpan or search on metacpan
deps/libgit2/include/git2/odb.h view on Meta::CPAN
* For most cases, it is preferred to write objects through a write
* stream, which is both faster and less memory intensive, specially
* for big objects.
*
* This method is provided for compatibility with custom backends
* which are not able to support streaming writes
*
* @param out pointer to store the OID result of the write
* @param odb object database where to store the object
* @param data buffer with the data to store
* @param len size of the buffer
deps/libgit2/include/git2/odb.h view on Meta::CPAN
GIT_EXTERN(int) git_odb_stream_finalize_write(git_oid *out, git_odb_stream *stream);
/**
* Read from an odb stream
*
* Most backends don't implement streaming reads
*
* @param stream the stream
* @param buffer a user-allocated buffer to store the data in.
* @param len the buffer's length
* @return 0 if the read succeeded, error code otherwise
deps/libgit2/include/git2/odb.h view on Meta::CPAN
GIT_EXTERN(void) git_odb_stream_free(git_odb_stream *stream);
/**
* Open a stream to read an object from the ODB
*
* Note that most backends do *not* support streaming reads
* because they store their objects as compressed/delta'ed blobs.
*
* It's recommended to use `git_odb_read` instead, which is
* assured to work on all backends.
*
view release on metacpan or search on metacpan
Documentation/TODO view on Meta::CPAN
it down any more :-).
But I could shorten the journey between XML and constructors, perhaps
libxml would help here although the time spent in XML::Parser is not great.
Or perhaps use a streaming approach. I don't think that it is possible to
show the dialog until it is completely constructed so it will just speed
up the building before showing it at the end of the stream.
Or perhaps write my own simple parser using regexps.
Documentation/TODO view on Meta::CPAN
* Improve PerlRun->create_pixmap() to use new bindings, possibly do in same
way that Glade C code in support.c does.
LONG TERM
---------
Use XML::Parser()s streaming approach or SAX interface to build UI as it
is read. This might be quicker and would also allow 'net delivery
of UIs. Write Glade::PerlGenerate->Form_from_(XML_)Stream.
Since on my 170MHz AMD K6/II a large reference form (136 kb) only takes 3
seconds to read and parse into the glade proto, this might not be worth
view release on metacpan or search on metacpan
lib/Gnuplot/Builder/Dataset.pm view on Meta::CPAN
my $y = $x * 10;
$writer->("$x $y\n");
}
});
This allows for very large inline data streaming directly into the gnuplot process.
If you don't pass any data to C<$writer>, it means the C<$dataset> doesn't have inline data at all.
=back
view release on metacpan or search on metacpan
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
my %name_of :ATTR(:get<name>);
my %fileSize_of :ATTR(:get<fileSize>);
my %creationTime_of :ATTR(:get<creationTime>);
my %Media__Type_of :ATTR(:get<Media__Type>);
my %durationMillis_of :ATTR(:get<durationMillis>);
my %streamingUrl_of :ATTR(:get<streamingUrl>);
my %readyToPlayOnTheWeb_of :ATTR(:get<readyToPlayOnTheWeb>);
__PACKAGE__->_factory(
[ qw( mediaId
type
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
name
fileSize
creationTime
Media__Type
durationMillis
streamingUrl
readyToPlayOnTheWeb
) ],
{
'mediaId' => \%mediaId_of,
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
'name' => \%name_of,
'fileSize' => \%fileSize_of,
'creationTime' => \%creationTime_of,
'Media__Type' => \%Media__Type_of,
'durationMillis' => \%durationMillis_of,
'streamingUrl' => \%streamingUrl_of,
'readyToPlayOnTheWeb' => \%readyToPlayOnTheWeb_of,
},
{
'mediaId' => 'SOAP::WSDL::XSD::Typelib::Builtin::long',
'type' => 'Google::Ads::AdWords::v201809::Media::MediaType',
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
'name' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
'fileSize' => 'SOAP::WSDL::XSD::Typelib::Builtin::long',
'creationTime' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
'Media__Type' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
'durationMillis' => 'SOAP::WSDL::XSD::Typelib::Builtin::long',
'streamingUrl' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
'readyToPlayOnTheWeb' => 'SOAP::WSDL::XSD::Typelib::Builtin::boolean',
},
{
'mediaId' => 'mediaId',
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
'name' => 'name',
'fileSize' => 'fileSize',
'creationTime' => 'creationTime',
'Media__Type' => 'Media.Type',
'durationMillis' => 'durationMillis',
'streamingUrl' => 'streamingUrl',
'readyToPlayOnTheWeb' => 'readyToPlayOnTheWeb',
}
);
} # end BLOCK
lib/Google/Ads/AdWords/v201809/Audio.pm view on Meta::CPAN
=over
=item * durationMillis
=item * streamingUrl
=item * readyToPlayOnTheWeb
view release on metacpan or search on metacpan
examples/advanced_operations/use_cross_account_bidding_strategy.pl view on Meta::CPAN
bidding_strategy.name,
bidding_strategy.type,
bidding_strategy.currency_code
FROM bidding_strategy";
# Issue a streaming search request, then iterate through and print the
# results.
my $search_stream_handler =
Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
service => $api_client->GoogleAdsService(),
request =>
examples/advanced_operations/use_cross_account_bidding_strategy.pl view on Meta::CPAN
# by a manager (and not also include the current customer's portfolio bidding
# strategies).
# $query .=
# " WHERE accessible_bidding_strategy.owner_customer_id != $customer_id";
# Issue a streaming search request, then iterate through and print the
# results.
my $search_stream_handler =
Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
service => $api_client->GoogleAdsService(),
request =>
view release on metacpan or search on metacpan
lib/Google/BigQuery.pm view on Meta::CPAN
$bq->insert(
table_id => $table_id,
values => $values,
);
# The first time a streaming insert occurs, the streamed data is inaccessible for a warm-up period of up to two minutes.
sleep(120);
# selectrow_array
my ($count) = $bq->selectrow_array(query => "SELECT COUNT(*) FROM $table_id");
print $count, "\n"; # 103
lib/Google/BigQuery.pm view on Meta::CPAN
);
=item * insert
Streams data into BigQuery one record at a time without needing to run a load job.
See details at https://cloud.google.com/bigquery/streaming-data-into-bigquery.
$bq->insert( # return 1 (success) or 0 (error)
project_id => $project_id, # required if default project is not set
dataset_id => $dataset_id, # required if default project is not set
table_id => $table_id, # required
view release on metacpan or search on metacpan
lib/Google/ProtocolBuffers/Dynamic.pm view on Meta::CPAN
implementation on top of C<Google::ProtocolBuffers::Dynamic>.
The exact interface of mapped methods depends on the underlying RPC
implementation (for example, for L<Grpc::XS>, the return value is a
subclass of L<Grpc::Client::AbstractCall>) and whether the method uses
client/server streaming.
=head2 INTROSPECTION
All mapped entities provide access to an introspection object that
describes the Protocol Buffers object definition.
view release on metacpan or search on metacpan
work under Win32!
- this is the Flight 63 edition
1.4 Wed Oct 3 07:57:42 GMT 2001
- added new filehandle, scalar reference, and code reference
scheme to as_* to allow streaming of data, rather than
accumulating potentially very large output in memory (based
on patch by Dave Rolsky)
- new pagewidth and pageheight graph attributes for creating
PostScript mosaics of large graphs (idea by Nelson Loyola)
view release on metacpan or search on metacpan
- DZI: stretch parameter != 1? then do a more intelligent crop:
1) crop larger than tile necessary
2) resize this (to avoid artefacts)
3) crop again, at tile size
- add Graphics::DZI::cpio (if there were a streaming solution)
- add Graphics::DZI::tar (if there were a *working* streaming solution
- add Graphics::DZI::DAV
- tests must be improved over time
- add --overlay option to deepzoom
view release on metacpan or search on metacpan
*July 2005 to July 2008 - Perl Internal Applications Engineer*
* Developed and maintained internal applications for server automations, the internal ticket system and employee client management.
* Leveraged technologies such as Perl, MySQL, Apache mod_perl, Template Toolkit and Bash Shell to enhance operational efficiency.
* Specialized in code optimization, resulting in improved application performance and reduced processing time.
* Contributed to a collaborative environment at Napster, a pioneering music streaming service in the greater San Diego area.
----
### 4Retired.com
*July 2003 to June 2004 - Chief Information Officer*
* Oversaw the complete IT infrastructure, including server build, maintenance and software developement.
* Designed and implemented a cusdtomized web portal featuring free email accounts and affiliate distribution.
* Enhanced operational efficiency by streaming server management on RedHat Linux, leading to improved uptime and performance.
----
### eBuilt
view release on metacpan or search on metacpan
examples/old_examples/imaging/ShrinkStream.pl view on Meta::CPAN
use Graphics::VTK;
$VTK_DATA = 0;
$VTK_DATA = $ENV{VTK_DATA};
# Halves the size of the image in the x, Y and Z dimensions.
# Computes the whole volume, but streams the input using the streaming
# functionality in vtkImageFilter class.
#source vtkImageInclude.tcl
# Image pipeline
$reader = Graphics::VTK::ImageReader->new;
$reader->SetDataByteOrderToLittleEndian;
view release on metacpan or search on metacpan
lib/Grpc/Client/BaseStub.pm view on Meta::CPAN
$call->start($argument, $metadata, $options);
return $call;
}
## Call a remote method with messages streaming in both directions.
##
## @param string $method The name of the method to call
## @param callable $serialize A function that serializes the request
## @param callable $deserialize A function that deserializes the responses
## @param array $metadata A metadata map to send to the server
view release on metacpan or search on metacpan
share/public/guaclite.js view on Meta::CPAN
return sum;
};
/**
* Converts the given AudioBuffer into an audio packet, ready for streaming
* along the underlying output stream. Unlike the raw audio packets used by
* this audio recorder, AudioBuffers require floating point samples and are
* split into isolated planes of channel-specific data.
*
* @private
view release on metacpan or search on metacpan
lib/Gzip/RandomAccess.pm view on Meta::CPAN
=head1 DESCRIPTION
This module allows you to randomly access a gzip deflate stream
as if it were a regular file, even though gzip is not designed
to be random-access. This is achieved by streaming the gzip file
in advance, building an index mapping compressed byte offsets to
uncompressed offsets, and at each point storing the 32KB of data
gzip needs to prime its decompression engine from that point.
The mechanism is taken from zran.c, an example in the zlib
view release on metacpan or search on metacpan
t/testpages/cnn.html view on Meta::CPAN
</TD><TD WIDTH="10"></TD><TD WIDTH="225">
<FONT FACE="helvetica, arial, sans-serif" SIZE="2">
<UL>
<li><a href="/WEATHER/9901/28/weather.page.pm.ap/">Cold and snowy across northern U.S.; rain elsewhere</a>
<LI><A HREF="/WEATHER/">Forecasts for 7,200 cities</A>
<LI><A HREF="/WEATHER/video/">Watch CNN's forecasts in streaming video</A>
</UL>
</FONT>
</TD></TR>
</TABLE>
view release on metacpan or search on metacpan
lib/HTML/HTML5/Parser/TagSoupParser.pm view on Meta::CPAN
$self->{line}++;
$self->{column} = 0;
} elsif ($self->{nc} == 0x000D) { # CR
## TODO: support for abort/streaming
my $next = '';
if ($input->read ($next, 1) and $next ne "\x0A") {
$self->{next_nc} = $next;
}
$self->{nc} = 0x000A; # LF # MUST
lib/HTML/HTML5/Parser/TagSoupParser.pm view on Meta::CPAN
if ($self->{nc} == 0x000A) { # LF
$p->{line}++;
$p->{column} = 0;
} elsif ($self->{nc} == 0x000D) { # CR
## TODO: support for abort/streaming
my $next = '';
if ($input->read ($next, 1) and $next ne "\x0A") {
$self->{next_nc} = $next;
}
$self->{nc} = 0x000A; # LF # MUST
view release on metacpan or search on metacpan
- removed dependency on HTML::Entities by hardcoding all relevant
entities. (HTML::Entities does a 'require HTML::Parser' which made the
parser=>0 feature break.)
- 0.09
- added Print feature to new() to allow Run() to return highlighted text
instead of automatically printing in a streaming fashion. Set Print=>0
to turn off print().
- Run() now returns highlighted text if Print=>0.
- changed parser=>0 to Parser=>0.
- the ParsedWords bug reported in 0.08 was really with my example in
get_snippet(). so rather than blame someone else's code, I fixed mine...
view release on metacpan or search on metacpan
iteration in succession using identical markup. You do this by creating a
<loop> tag in your template file containing the markup to be repeated, and
by creating a correspondingly named Loop object attached to the HTML::Macro
and containing all the data to be interpolated. Note: this requires all
data to be fetched and stored before it is applied to the template; there
is no facility for streaming data. For the intended use this is not a
problem. However it militates against using HTML::Macro for text
processing of very large datasets.
<loop id="people">
<tr><td>#first_name# #last_name#</td><td>#email#</td></tr>
view release on metacpan or search on metacpan
- basic test for leaks
- Slightly change the internal invoke_mason method for easier reuse
(Ask Bjørn Hansen)
0.52 October 22, 2010
- Add streaming handler, HTML::Mason::PSGIHandler::Streamy. (Chia-liang Kao)
0.51 October 18, 2010
- For body-less response, don't return an undef body element (Chia-liang Kao)
- Pass Mason -Status into psgi_header (Shawn M Moore)
view release on metacpan or search on metacpan
TableExtractor.pm view on Meta::CPAN
=head2 EXPORTS
=head2 CAVEATS, BUGS, and TODO
o parse() should handle other data sources, such as streaming, file handle
etc.
=head2 SEE ALSO
view release on metacpan or search on metacpan
lib/HTML/Zoom.pm view on Meta::CPAN
1;
=head1 NAME
HTML::Zoom - selector based streaming template engine
=head1 SYNOPSIS
use HTML::Zoom;
lib/HTML/Zoom.pm view on Meta::CPAN
having got this class itself at least somewhat documented I figured now was
a good time to cut a first real release.
=head1 DESCRIPTION
HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional,
CSS selector based semantic templating engine for HTML and HTML-like
document formats.
Which is, on the whole, a bit of a mouthful. So let me step back a moment
and explain why you care enough to understand what I mean:
lib/HTML/Zoom.pm view on Meta::CPAN
HTML::Zoom's filehandle object supports an additional event key, 'flush',
that is transparent to the rest of the system but indicates to the filehandle
object to end a getline operation at that point and return the HTML so far.
This means that in an environment where streaming output is available, such
as a number of the L<Plack> PSGI handlers, you can add the flush key to an
event in order to ensure that the HTML generated so far is flushed through
to the browser right now. This can be especially useful if you know you're
about to call a web service or a potentially slow database query or similar
to ensure that at least the header/layout of your page renders now, improving
lib/HTML/Zoom.pm view on Meta::CPAN
To which I say, "eh", "meh", and possibly also "feh". If it really upsets
you, either use extra classes for this (and remove them afterwards) or
use special fake elements or, well, honestly, just use something different.
L<Template::Semantic> provides a similar idea to zoom except using XPath
and XML::LibXML transforms rather than a lightweight streaming approach -
maybe you'd like that better. Or maybe you really did want
L<Template Toolkit|Template> after all. It is still damn good at what it does,
after all.
So far, however, I've found that for new sites the designers I'm working with
lib/HTML/Zoom.pm view on Meta::CPAN
=head2 GET THEE TO A SUMMARY!
Erm. Well.
HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional,
CSS selector based semantic templating engine for HTML and HTML-like
document formats.
But I said that already. Although hopefully by now you have some idea what I
meant when I said it. If you didn't have any idea the first time. I mean, I'm
view release on metacpan or search on metacpan
lib/HTTP/Daemon/Threaded/CGIAdapter.pm view on Meta::CPAN
<p>
Developers should be judicious in their use of the CGI interface for
HTTP::Daemon::Threaded: if the request is to return a very large (i.e.,
multi-megabyte) response, the underlying I/O buffering may consume
significant memory resources. Likewise, this package does not support
some methods of "Comet"-style streaming client-server interaction, as the
response buffer will not be dispatched to the client until the CGI
invokation has completed.
<p>
Copyright© 2008, Dean Arnold, Presicient Corp., USA<br>
All rights reserved.
view release on metacpan or search on metacpan
lib/HTTP/Engine/Interface/PSGI.pm view on Meta::CPAN
finalize => sub { _finalize(@_) },
},
},
;
sub can_has_streaming { 1 }
sub run {
my($self, $env) = @_;
# get PSGI response arrayrey. generated by _finalize
lib/HTTP/Engine/Interface/PSGI.pm view on Meta::CPAN
},
);
my $app = sub { $engine->run(@_) };
Plack::Loader->load('Standalone', port => 801)->run($app); # see L<Plack::Server::Standalone> and L<Plack::Loader>
if you want streaming response
use HTTP::Engine;
use IO::Handle::Util qw(io_from_getline); # see L<IO::Handle::Util>
use Plack::Loader;
my $count = 1;