view release on metacpan or search on metacpan
lib/Mail/SpamAssassin/Plugin/OLEVBMacro.pm view on Meta::CPAN
=back
=cut
# https://blogs.msdn.microsoft.com/vsofficedeveloper/2008/05/08/office-2007-file-format-mime-types-for-http-content-streaming-2/
# https://technet.microsoft.com/en-us/library/ee309278(office.12).aspx
push(@cmds, {
setting => 'olemacro_exts',
default => qr/(?:doc|docx|dot|pot|ppa|pps|ppt|rtf|sldm|xl|xla|xls|xlsx|xlt|xltx|xslb)$/,
view release on metacpan or search on metacpan
0.18 2012-03-04
- The Markdent::Handler::HTMLStream::Document and ::Fragment modules did not
detect when streaming to a file handle failed. This is because HTML::Stream
does not check that it's calls to ->print succeed. This has been fixed by
wrapping file handles (native or IO::Handle) in an object which checks that
print succeeds.
- Distro/packaging cleanup.
view release on metacpan or search on metacpan
lib/MarpaX/ESLIF.pm view on Meta::CPAN
Matching supports natively regular expression using the L<PCRE2|http://www.pcre.org/> library.
=item Streaming
Native support of streaming input.
=item Sub-grammars
The number of sub grammars is unlimited.
view release on metacpan or search on metacpan
lib/Mason/Manual/Components.pod view on Meta::CPAN
=head2 Output versus return value
Most Mason methods output content such as HTML. The content is not actually
returned, but is instead appended to an implicit buffer. This is slightly more
complicated but is necessary for supporting streaming applications.
When Mason generates C<main> and other methods declared with C<< <%method> >>,
it puts an implicit
return undef;
view release on metacpan or search on metacpan
lib/Mastodon/Client.pm view on Meta::CPAN
my $endpoint
= $self->instance->uri
. '/api/v'
. $self->api_version
. '/streaming/'
. (( $query =~ /^#/ )
? ( 'hashtag?' . $query )
: $query
);
lib/Mastodon/Client.pm view on Meta::CPAN
$listener->start;
=head1 DESCRIPTION
Mastodon::Client lets you talk to a Mastodon server to obtain authentication
credentials, read posts from timelines in both static or streaming mode, and
perform all the other operations exposed by the Mastodon API.
Most of these are available through the convenience methods listed below, which
validate input parameters and are likely to provide more meaningful feedback in
case of errors.
lib/Mastodon/Client.pm view on Meta::CPAN
=back
=head1 STREAMING RESULTS
Alternatively, it is possible to use the streaming API to get a constant stream
of updates. To do this, there is the B<stream()> method.
=over 4
=item B<stream($query)>
lib/Mastodon/Client.pm view on Meta::CPAN
the particular tag.
For more details on how to use this object, see the documentation for
L<Mastodon::Listener>.
Accessing streaming public timeline does not require authentication.
=back
=head1 REQUEST METHODS
view release on metacpan or search on metacpan
lib/Math/LiveStats.pm view on Meta::CPAN
# perl -MPod::Markdown -e 'Pod::Markdown->new->filter(@ARGV)' lib/Math/LiveStats.pm > README.md
=head1 NAME
Math::LiveStats - Pure perl module to make mean, standard deviation, vwap, and p-values available for one or more window sizes in streaming data
=head1 SYNOPSIS
#!/usr/bin/perl -w
lib/Math/LiveStats.pm view on Meta::CPAN
cat data | perl -MMath::LiveStats -ne 'BEGIN{$s=Math::LiveStats->new(20);} chomp;($t,$p,$v)=split(/,/); $s->add($t,$p,$v); print "$t,$p,$v,",$s->n(20),",",$s->mean(20),",",$s->stddev(20),",",$s->vwap(20),",",$s->vwapdev(20),"\n"'
=head1 DESCRIPTION
Math::LiveStats provides live statistical calculations (mean, standard deviation, p-value,
volume-weighted-average-price and stddev vwap) over multiple window sizes for streaming
data. It uses West's algorithm for efficient updates and supports synthetic boundary
entries to maintain consistent results.
Stats are computed based on data that exists inside the given window size, plus possibly
one (at most) synthetic entry: when old data shuffles out of the window, if there's no
view release on metacpan or search on metacpan
lib/Math/SZaru.pm view on Meta::CPAN
The one unifying aspect of the implemented aggregators is that
they work with a single pass and with bounded memory overhead.
In CS terms, they should have near C<O(n)> compute complexity
and C<O(1)> or at least sub-linear memory overhead. The algorithms
may trade accuracy (hence I<*Estimator>) for this goal and are
intended for use with large and/or streaming data sets that
either do not fit in memory or whose total size is unknown.
The functionality is currently divided between three classes:
L<Math::SZaru::UniqueEstimator>, L<Math::SZaru::TopEstimator>,
and L<Math::SZaru::QuantileEstimator>. For details on those,
view release on metacpan or search on metacpan
src/linalg3d.cc view on Meta::CPAN
// Cross product
inline Vec TPS::cross(const Vec &a, const Vec &b) {
return Vec( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x );
}
// streaming
std::ostream&
TPS::operator<<(std::ostream& stream, Vec const& obj)
{
obj.WriteTo(stream);
return stream;
view release on metacpan or search on metacpan
src/libmemcached/libmemcached/memcached/protocol_binary.h view on Meta::CPAN
* server will transmit everything it contains.
*
* The first 8 bytes in the engine specific data contains
* the oldest entry (from epoc) you're interested in.
* Specifying a time in the future (for the server you are
* connecting to), will cause it to start streaming current
* changes.
*/
#define TAP_CONNECT_FLAG_BACKFILL 0x01
/**
* Dump will cause the server to send the data stored on the
view release on metacpan or search on metacpan
lib/Plack/App/Message/Passing.pm view on Meta::CPAN
do {
$len = $input_fh->read(my $buf, 4096);
$input .= $buf;
} while ($len);
$env->{'psgi.input'} = $input;
delete $env->{'psgi.streaming'};
$env->{'psgix.message.passing.clientid'} = refaddr($base_env);
$env->{'psgix.message.passing.returnaddress'} = $self->return_address;
$self->output_to->consume(encode_json $env);
return sub {
my $responder = shift;
view release on metacpan or search on metacpan
t/51-stream.t view on Meta::CPAN
field $app :param;
field $route :param;
method a {
sub {
my $w = shift->([ 200, [] ]);
$w->write('streaming');
$w->close;
}
};
}
EOF
t/51-stream.t view on Meta::CPAN
my $app = Minima::App->new();
my $test = Plack::Test->create(sub { $app->set_env(shift); $app->run });
# Basic responses
my $res = $test->request(GET '/');
is( $res->content, "streaming", 'handles streaming properly' );
$res = $test->request(HEAD '/');
is( length($res->content), 0, 'returns empty body for HEAD (streaming)' );
}
chdir;
done_testing;
view release on metacpan or search on metacpan
0.10 Wed Jun 15 18:36:41 CEST 2011
- clear subrequest's headers_in table before running it in fetch_url
0.09 Fri Jun 10 16:58:00 CEST 2011
- streaming interface for fetch_url()
0.08 Mon Mar 14 20:14:39 CET 2011
- next try to fix the close_fd bug. fileno(DIRHANDLE) does not work
in Perl.
view release on metacpan or search on metacpan
debian/changelog view on Meta::CPAN
-- Dave Lambley <davel@state51.co.uk> Tue, 26 Jul 2011 11:07:05 +0000
libmogilefs-client-async-perl (0.011-1) unstable; urgency=low
* New streaming uploads into Mogile.
-- Dave Lambley <davel@state51.co.uk> Mon, 25 Jul 2011 12:38:37 +0100
libmogilefs-client-async-perl (0.010-1) unstable; urgency=low
view release on metacpan or search on metacpan
doc/checksums.txt view on Meta::CPAN
Ideally, mogstored checksum calculation is done by mogstored and only
the checksum (in $HASHTYPE=$HEXDIGEST format) is sent over the wire.
If mogstored is not available, the checksum is calculated on the tracker
by streaming the file with HTTP GET.
create_close (query worker)
---------------------------
New optional parameters:
view release on metacpan or search on metacpan
bench/selectors.pl view on Meta::CPAN
<h1><a class='u' href='#___top' title='click to go to top of document'
name="NAME"
>NAME <img alt='^' src='http://st.pimg.net/tucs/img/up.gif'></a></h1>
<p>HTML::Zoom - selector based streaming template engine</p>
<h1><a class='u' href='#___top' title='click to go to top of document'
name="SYNOPSIS"
>SYNOPSIS <img alt='^' src='http://st.pimg.net/tucs/img/up.gif'></a></h1>
bench/selectors.pl view on Meta::CPAN
<h1><a class='u' href='#___top' title='click to go to top of document'
name="DESCRIPTION"
>DESCRIPTION <img alt='^' src='http://st.pimg.net/tucs/img/up.gif'></a></h1>
<p>HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional, CSS selector based semantic templating engine for HTML and HTML-like document formats.</p>
<p>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:</p>
<h2><a class='u' href='#___top' title='click to go to top of document'
name="JQUERY_ENVY"
bench/selectors.pl view on Meta::CPAN
<p>... and by Weasel, I mean layout.</p>
<p>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.</p>
<p>This means that in an environment where streaming output is available, such as a number of the <a href="/perldoc?Plack" class="podlinkpod"
>Plack</a> 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 poten...
<p>This is currently exposed by the 'flush_before' option to the collect filter, which incidentally also underlies the replace and repeat filters, so to indicate we want this behaviour to happen before a query is executed we can write somethi...
<pre class="prettyprint"> $zoom->select('.item')->repeat(sub {
bench/selectors.pl view on Meta::CPAN
>SEMANTIC DIDACTIC</a></h2>
<p>Some will argue that overloading CSS selectors to do data stuff is a terrible idea, and possibly even a step towards the "Concrete Javascript" pattern (which I abhor) or Smalltalk's Morphic (which I ignore, except for the part where it...
<p>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. <a...
>Template::Semantic</a> 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 <a href="/perldoc?Template" class="pod...
>Template Toolkit</a> after all. It is still damn good at what it does, after all.</p>
<p>So far, however, I've found that for new sites the designers I'm working with generally want to produce nice semantic HTML with classes that represent the nature of the data rather than the structure of the layout, so sharing them as a com...
<p>In the absence of any evidence that overloading CSS selectors has killed children or unexpectedly set fire to grandmothers - and given microformats have been around for a while there's been plenty of opportunity for octagenarian combustion - I...
bench/selectors.pl view on Meta::CPAN
name="GET_THEE_TO_A_SUMMARY!"
>GET THEE TO A SUMMARY!</a></h2>
<p>Erm. Well.</p>
<p>HTML::Zoom is a lazy, stream oriented, streaming capable, mostly functional, CSS selector based semantic templating engine for HTML and HTML-like document formats.</p>
<p>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 not trying to call you stupid or anything. Just saying that maybe it wasn't tota...
<p>Er.</p>
view release on metacpan or search on metacpan
examples/streaming.pl view on Meta::CPAN
consumer_key => 'z',
consumer_secret => 'x',
access_token => '1-z',
access_token_secret => 'x',
);
$twitter->streaming('https://userstream.twitter.com/1.1/user.json', { with => 'followings' }, sub {
my ($tweet) = @_;
say Dumper(\$tweet);
});
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/MountPSGI/Proxy.pm view on Meta::CPAN
#TODO do something with $self->mode in delayed response
# delayed (code reference) response
my $responder = sub {
my $plack_res = shift;
my ($mojo_res, $streaming) = _psgi_res_to_mojo_res($plack_res);
$c->tx->res($mojo_res);
return $c->rendered unless $streaming;
# streaming response, possibly chunked
my $chunked = $mojo_res->content->is_chunked;
my $write = $chunked ? sub { $c->write_chunk(@_) } : sub { $c->write(@_) };
$write->(); # finalize header response
return Plack::Util::inline_object(
write => $write,
lib/Mojolicious/Plugin/MountPSGI/Proxy.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.input' => $input,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
};
}
sub _psgi_res_to_mojo_res {
lib/Mojolicious/Plugin/MountPSGI/Proxy.pm view on Meta::CPAN
my $headers = $mojo_res->headers;
Plack::Util::header_iter $psgi_res->[1] => sub { $headers->header(@_) };
$headers->remove('Content-Length'); # should be set by mojolicious later
my $streaming = 0;
if (@$psgi_res == 3) {
my $asset = $mojo_res->content->asset;
Plack::Util::foreach($psgi_res->[2], sub {$asset->add_chunk($_[0])});
} else {
$streaming = 1;
}
return ($mojo_res, $streaming);
}
1;
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/PlackMiddleware.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.input' => $body,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
};
}
### ---
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/RenderFile.pm view on Meta::CPAN
'cleanup' => 1, # delete file after completed
);
=head1 DESCRIPTION
L<Mojolicious::Plugin::RenderFile> is a L<Mojolicious> plugin that adds "render_file" helper. It does not read file in memory and just streaming it to a client.
=head1 HELPERS
=head2 C<render_file>
view release on metacpan or search on metacpan
lib/Mojolicious/Plugin/WebAPI/Proxy.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.input' => $body,
'psgi.multithread' => Plack::Util::FALSE,
'psgi.multiprocess' => Plack::Util::TRUE,
'psgi.run_once' => Plack::Util::FALSE,
'psgi.streaming' => Plack::Util::TRUE,
'psgi.nonblocking' => Plack::Util::FALSE,
};
}
sub _psgi_res_to_mojo_res {
view release on metacpan or search on metacpan
- Added EXPERIMENTAL bytes_waiting and can_write methods to Mojo::IOLoop::Stream.
- Added EXPERIMENTAL high_water_mark attribute to Mojo::IOLoop::Stream.
- Updated bundled TLS certificate.
- Improved Mojo::Base flags not to require a certain order.
- Improved clone performance in Mojo::Headers by 100%.
- Improved streaming response performance slightly.
- Fixed a typo in the 425 status message in Mojo::Message::Response. (CandyAngel)
- Fixed a missing deprecation warning in Mojo::Promise. (marcus)
8.17 2019-05-23
- Fixed a bug in Mojo::UserAgent where the request timeout would not work for keep-alive requests. (ilmari)
view release on metacpan or search on metacpan
lib/MongoDB/GridFSBucket.pm view on Meta::CPAN
filehandle-like: you get an object that you can read/write from similar to a filehandle. You can even get a tied filehandle that you can hand off to other code that requires an actual Perl handle.
=item *
streaming: you provide a file handle to read from (upload) or print to (download) and data is streamed to (upload) or from (download) GridFS until EOF.
=back
=head2 Error handling
view release on metacpan or search on metacpan
lib/Monoceros/Server.pm view on Meta::CPAN
'psgi.errors' => *STDERR,
'psgi.url_scheme' => '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' => $conn->{fh},
'psgix.harakiri' => 1,
'X_MONOCEROS_WORKER_STATS' => $self->{stats_filename},
view release on metacpan or search on metacpan
deps/msgpack-c/CHANGELOG.md view on Meta::CPAN
* Fix empty map parse bug (#568)
* Improve build system (#569, #570, #572, #579, #591, #592)
* Remove some warnings (#574, #578, #586, #588)
* Improve cross platform configuration (#577, #582)
* Add cmake package config support (#580)
* Fix streaming unpack bug (#585)
# 2017-02-04 version 2.1.1
* Fix unpacker's buffer management bug (#561)
* Add boost string_view adaptor (#558)
deps/msgpack-c/CHANGELOG.md view on Meta::CPAN
* ./configure supports --disable-cxx option not to build C++ API
# 2010-04-29 version 0.5.0:
* msgpack_object_type is changed. MSGPACK_OBJECT_NIL is now 0x00.
* New safe streaming deserializer API.
* Add object::object(const T&) and object::operator=(const T&)
* Add operator==(object, const T&)
* MSGPACK_DEFINE macro defines msgpack_object(object* obj, zone* z)
* C++ programs doesn't need to link "msgpackc" library.
view release on metacpan or search on metacpan
bin/mythfs.pl view on Meta::CPAN
recordings can be found. The filesystem will then be set up as a set
of symbolic links that point from a human readable file name to the
recording file.
The main advantage of creating symbolic links is that NFSv4 can be
noticeably faster than the backend streaming protocol -- about a 25%
improvement on my local network. The main limitation is that this mode
does not understand storage groups, so all recordings need to be
located in a single storage group in a locally-accessible
directory. However if a recording file is not found in local
directory, then mythfs.pl will fall back to the streaming protocol, so
the recording is accessible one way or another.
=head2 The Default Directory Layout
Recordings that are part of a series usually have a title (the series
view release on metacpan or search on metacpan
build/lib/src/result_stream.c view on Meta::CPAN
neo4j_memory_allocator_t *allocator;
neo4j_mpool_t mpool;
neo4j_mpool_t record_mpool;
unsigned int refcount;
unsigned int starting;
unsigned int streaming;
int statement_type;
struct neo4j_statement_plan *statement_plan;
struct neo4j_update_counts update_counts;
unsigned long long available_after;
unsigned long long consumed_after;
build/lib/src/result_stream.c view on Meta::CPAN
goto failure;
}
(results->refcount)++;
results->starting = true;
results->streaming = true;
return &(results->_result_stream);
int errsv;
failure:
errsv = errno;
build/lib/src/result_stream.c view on Meta::CPAN
goto failure;
}
(results->refcount)++;
results->starting = true;
results->streaming = true;
return &(results->_result_stream);
int errsv;
failure:
errsv = errno;
build/lib/src/result_stream.c view on Meta::CPAN
results->last_fetched = NULL;
}
if (results->records == NULL)
{
if (!results->streaming)
{
errno = results->failure;
return NULL;
}
assert(results->failure == 0);
build/lib/src/result_stream.c view on Meta::CPAN
errno = results->failure;
return NULL;
}
if (results->records == NULL)
{
assert(!results->streaming);
errno = results->failure;
return NULL;
}
}
build/lib/src/result_stream.c view on Meta::CPAN
run_result_stream_t, _result_stream);
REQUIRE(results != NULL, NULL);
if (results->records_depth <= depth)
{
if (!results->streaming)
{
errno = results->failure;
return NULL;
}
build/lib/src/result_stream.c view on Meta::CPAN
return NULL;
}
if (results->records_depth <= depth)
{
assert(!results->streaming);
errno = results->failure;
return NULL;
}
}
build/lib/src/result_stream.c view on Meta::CPAN
{
run_result_stream_t *results = container_of(self,
run_result_stream_t, _result_stream);
REQUIRE(results != NULL, 0);
if (results->failure != 0 || await(results, &(results->streaming)))
{
assert(results->failure != 0);
errno = results->failure;
return 0;
}
build/lib/src/result_stream.c view on Meta::CPAN
{
run_result_stream_t *results = container_of(self,
run_result_stream_t, _result_stream);
REQUIRE(results != NULL, -1);
if (results->failure != 0 || await(results, &(results->streaming)))
{
assert(results->failure != 0);
errno = results->failure;
return -1;
}
build/lib/src/result_stream.c view on Meta::CPAN
{
run_result_stream_t *results = container_of(self,
run_result_stream_t, _result_stream);
REQUIRE(results != NULL, NULL);
if (results->failure != 0 || await(results, &(results->streaming)))
{
assert(results->failure != 0);
errno = results->failure;
return NULL;
}
build/lib/src/result_stream.c view on Meta::CPAN
{
errno = EINVAL;
goto failure;
}
if (results->failure != 0 || await(results, &(results->streaming)))
{
assert(results->failure != 0);
errno = results->failure;
goto failure;
}
build/lib/src/result_stream.c view on Meta::CPAN
{
run_result_stream_t *results = container_of(self,
run_result_stream_t, _result_stream);
REQUIRE(results != NULL, -1);
results->streaming = false;
assert(results->refcount > 0);
--(results->refcount);
int err = await(results, &(results->refcount));
// even if await fails, queued messages should still be drained
assert(results->refcount == 0);
build/lib/src/result_stream.c view on Meta::CPAN
return;
}
job->next = NULL;
results->connection = NULL;
if (results->streaming && results->failure == 0)
{
set_failure(results, err);
}
}
build/lib/src/result_stream.c view on Meta::CPAN
}
return 1;
}
--(results->refcount);
results->streaming = false;
// not a record, so keep this memory along with the result stream
if (neo4j_mpool_merge(&(results->mpool), &(results->record_mpool)) < 0)
{
neo4j_log_trace_errno(results->logger, "neo4j_mpool_merge failed");
build/lib/src/result_stream.c view on Meta::CPAN
assert(cdata != NULL);
assert(argc == 0 || argv != NULL);
run_result_stream_t *results = (run_result_stream_t *)cdata;
--(results->refcount);
results->streaming = false;
return stream_end(results, type, "DISCARD_ALL", argv, argc);
}
build/lib/src/result_stream.c view on Meta::CPAN
return -1;
}
(results->nrecords)++;
if (!results->streaming)
{
// discard memory for the record
neo4j_mpool_drain(&(results->record_mpool));
return 0;
}
build/lib/src/result_stream.c view on Meta::CPAN
void set_failure(run_result_stream_t *results, int error)
{
assert(results != NULL);
assert(error != 0);
results->failure = error;
results->streaming = false;
results->awaiting_records = 0;
memset(&(results->failure_details), 0, sizeof(results->failure_details));
}
view release on metacpan or search on metacpan
- deprecate experimental suppression of exceptions (die_on_error = 0)
0.13 2019-10-14
- declare API stable
- add record streaming interface to StatementResult
- implement Cypher type system, returning Neo4j entities as blessed objects
- methods returning lists now expect to be called in list context
- change HTTP transactions to make query statistics available by default
- experimental support for HTTPS
view release on metacpan or search on metacpan
lib/Net/AMQP/PP.pm view on Meta::CPAN
use JSON ();
our $VERSION = '0.01';
my $data = JSON::from_json(
q[{"domain":{"delivery tag":{"type":"longlong"},"exchange name":{"type":"shortstr"},"reply code":{"type":"short"},"consumer tag":{"type":"shortstr"},"path":{"type":"shortstr"},"class id":{"type":"short"},"access ticket":{"type":"short"},"queue name":...
sub import {
local $INC{"XML/LibXML.pm"} = 1;
require Net::AMQP;
require Net::AMQP::Protocol;
view release on metacpan or search on metacpan
lib/Net/AMQP/Protocol/v0_8.pm view on Meta::CPAN
=item I<consume_rate> (type: long)
Transfer rate in octets/second
Specifies a desired transfer rate in octets per second. This is usually determined by the application that uses the streaming data. A value of zero means "no limit", i.e. as rapidly as possible.
=item I<global> (type: bit)
Apply to entire connection
lib/Net/AMQP/Protocol/v0_8.pm view on Meta::CPAN
<!--
======================================================
== STREAMING
======================================================
-->
work with streaming content
<doc>
The stream class provides methods that support multimedia streaming.
The stream class uses the following semantics: one message is one
packet of data; delivery is unacknowleged and unreliable; the consumer
can specify quality of service parameters that the server can try to
adhere to; lower-priority messages may be discarded in favour of high
priority messages.
lib/Net/AMQP/Protocol/v0_8.pm view on Meta::CPAN
<field name = "consume rate" type = "long">
transfer rate in octets/second
<doc>
Specifies a desired transfer rate in octets per second. This is
usually determined by the application that uses the streaming
data. A value of zero means "no limit", i.e. as rapidly as
possible.
</doc>
<doc name = "rule">
The server MAY ignore the prefetch values and consume rates,
lib/Net/AMQP/Protocol/v0_8.pm view on Meta::CPAN
the queue was declared as private, and ideally, impose no limit
except as defined by available resources.
</doc>
<doc name = "rule">
Streaming applications SHOULD use different channels to select
different streaming resolutions. AMQP makes no provision for
filtering and/or transforming streams except on the basis of
priority-based selective delivery of individual messages.
</doc>
<chassis name = "server" implement = "MUST" />
<response name = "consume-ok" />
view release on metacpan or search on metacpan
lib/Net/API/Telegram.pm view on Meta::CPAN
This parameter type is Integer and is optional.
If the message is a reply, ID of the original message
=item I<supports_streaming>
This parameter type is Boolean and is optional.
Pass True, if the uploaded video is suitable for streaming
=item I<thumb>
This parameter type is one of the following L<InputFile> or String and is optional.
Thumbnail of the file sent; can be ignored if thumbnail generation for the file is supported server-side. The thumbnail should be in JPEG format and less than 200 kB in size. A thumbnail‘s width and height should not exceed 320. Ignored if the file...