Result:
found more than 613 distributions - search limited to the first 2001 files matching your query
( run in 0.997 )
Lingua-ZH-Jieba
view release on metacpan or search on metacpan
cppjieba/deps/gtest/include/gtest/gtest-message.h view on Meta::CPAN
// stream a pointer to a Message, this definition will be used as it
// is more specialized. (The C++ Standard, section
// [temp.func.order].) If you stream a non-pointer, then the
// previous definition will be used.
//
// The reason for this overload is that streaming a NULL pointer to
// ostream is undefined behavior. Depending on the compiler, you
// may get "0", "(nil)", "(null)", or an access violation. To
// ensure consistent result across compilers, we always treat NULL
// as "(null)".
template <typename T>
cppjieba/deps/gtest/include/gtest/gtest-message.h view on Meta::CPAN
#endif // GTEST_OS_SYMBIAN
// Since the basic IO manipulators are overloaded for both narrow
// and wide streams, we have to provide this specialized definition
// of operator <<, even though its body is the same as the
// templatized version above. Without this definition, streaming
// endl or other basic IO manipulators to Message will confuse the
// compiler.
Message& operator <<(BasicNarrowIoManip val) {
*ss_ << val;
return *this;
cppjieba/deps/gtest/include/gtest/gtest-message.h view on Meta::CPAN
// Instead of 1/0, we want to see true/false for bool values.
Message& operator <<(bool b) {
return *this << (b ? "true" : "false");
}
// These two overloads allow streaming a wide C string to a Message
// using the UTF-8 encoding.
Message& operator <<(const wchar_t* wide_c_str) {
return *this << internal::String::ShowWideCString(wide_c_str);
}
Message& operator <<(wchar_t* wide_c_str) {
Linux-Event-Fork
view release on metacpan or search on metacpan
examples/91_stress_stdin_with_timeout.pl view on Meta::CPAN
use warnings;
use Linux::Event;
use Linux::Event::Fork;
# STRESS TEST: stdin streaming + timeout interaction
# This stresses:
# - backpressure-aware stdin streaming queue
# - timeout firing while stdin is still being written
# - teardown stability (timer cancel, watchers, fds) after EPIPE/SIGPIPE conditions
#
# Expected:
# - timeout fires
Linux-Inotify2
view release on metacpan or search on metacpan
- no internal changes.
1.01 Tue Dec 20 12:31:16 CET 2005
- more fixes by Andrejs Dubovskis:
- removed debugging code accidentally left in.
- streaming API didn't always return properly blessed objects.
1.0 Mon Dec 19 17:48:01 CET 2005
- incorporated a major patch by Andrejs Dubovskis:
- added a non-callback interface to read events
- better error handling in non-blocking case.
Lugh
view release on metacpan or search on metacpan
lib/Lugh/Inference.pm view on Meta::CPAN
max_tokens => 50,
greedy => 1,
);
print $tokenizer->decode(\@tokens);
# Creative generation with streaming
@tokens = $inference->generate(\@prompt,
max_tokens => 100,
temperature => 1.0,
top_p => 0.95,
callback => sub {
lib/Lugh/Inference.pm view on Meta::CPAN
temperature => 0.8,
top_p => 0.95,
);
print $tokenizer->decode(\@generated);
For streaming output:
my @generated = $inference->generate(\@prompt,
max_tokens => 100,
temperature => 0.8,
callback => sub {
LyricFinder
view release on metacpan or search on metacpan
lib/LyricFinder.pm view on Meta::CPAN
lyrics sites, as needed/desired by the user programatically.
We've also changed the default to search the supported sites randomly, instead
of in the same fixed alphabetical order by module name ("load-balancing" the
searches to all the sites). This is helpful when using LyricFinder as a
plugin for streaming media players, such as the author's very own "Fauxdacious
Media Player" that frequently stream internet radio stations, which can
impose a "hit" on the lyrics sites each time the song title changes. This
reduces the odds of a user's IP-address possibly being banned by a lyrics site
for "too-frequent scraping / usage"! NOTE: If you want to prevent the usage
of one or more of the specific sites, simply specify the I<-omit> argument with
MARC-Schema
view release on metacpan or search on metacpan
share/marc-schema.json view on Meta::CPAN
{"$schema":"https://format.gbv.de/schema/avram/schema.json","title":"MARC 21 Format for Bibliographic Data.","description":"MARC 21 Format for Bibliographic Data.","url":"https://www.loc.gov/marc/bibliographic/","fields":{"LDR":{"repeatable":false,"p...
MCP
view release on metacpan or search on metacpan
any '/mcp' => $server->to_action;
app->start;
Authentication can be added by the web application, just like for any other route. To allow for MCP applications to
scale with prefork web servers, server to client streaming is currentlly avoided when possible.
=head3 Stdio Transport
Build local command line applications and use the stdio transport for testing with the L<MCP::Server/"to_stdio">
method.
MHFS-XS
view release on metacpan or search on metacpan
miniaudio/miniaudio.h view on Meta::CPAN
1.2. High Level API
-------------------
The high level API consists of three main parts:
* Resource management for loading and streaming sounds.
* A node graph for advanced mixing and effect processing.
* A high level "engine" that wraps around the resource manager and node graph.
The resource manager (`ma_resource_manager`) is used for loading sounds. It supports loading sounds
fully into memory and also streaming. It will also deal with reference counting for you which
avoids the same sound being loaded multiple times.
The node graph is used for mixing and effect processing. The idea is that you connect a number of
nodes into the graph by connecting each node's outputs to another node's inputs. Each node can
implement it's own effect. By chaining nodes together, advanced mixing and effect processing can
miniaudio/miniaudio.h view on Meta::CPAN
```c
ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_STREAM, pGroup, NULL, &sound);
```
When streaming sounds, 2 seconds worth of audio data is stored in memory. Although it should work
fine, it's inefficient to use streaming for short sounds. Streaming is useful for things like music
tracks in games.
When you initialize a sound, if you specify a sound group the sound will be attached to that group
automatically. If you set it to NULL, it will be automatically attached to the engine's endpoint.
If you would instead rather leave the sound unattached by default, you can can specify the
miniaudio/miniaudio.h view on Meta::CPAN
6. Resource Management
======================
Many programs will want to manage sound resources for things such as reference counting and
streaming. This is supported by miniaudio via the `ma_resource_manager` API.
The resource manager is mainly responsible for the following:
* Loading of sound files into memory with reference counting.
* Streaming of sound data
miniaudio/miniaudio.h view on Meta::CPAN
available because the asynchronous decoding hasn't caught up, `MA_BUSY` will be returned by
`ma_data_source_read_pcm_frames()`.
For large sounds, it's often prohibitive to store the entire file in memory. To mitigate this, you
can instead stream audio data which you can do by specifying the
`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. When streaming, data will be decoded in 1
second pages. When a new page needs to be decoded, a job will be posted to the job queue and then
subsequently processed in a job thread.
For in-memory sounds, reference counting is used to ensure the data is loaded only once. This means
multiple calls to `ma_resource_manager_data_source_init()` with the same file path will result in
miniaudio/miniaudio.h view on Meta::CPAN
---------------------------------------------
When loading asynchronously, it can be useful to poll whether or not loading has finished. Use
`ma_resource_manager_data_source_result()` to determine this. For in-memory sounds, this will
return `MA_SUCCESS` when the file has been *entirely* decoded. If the sound is still being decoded,
`MA_BUSY` will be returned. Otherwise, some other error code will be returned if the sound failed
to load. For streaming data sources, `MA_SUCCESS` will be returned when the first page has been
decoded and the sound is ready to be played. If the first page is still being decoded, `MA_BUSY`
will be returned. Otherwise, some other error code will be returned if the sound failed to load.
In addition to polling, you can also use a simple synchronization object called a "fence" to wait
for asynchronously loaded sounds to finish. This is called `ma_fence`. The advantage to using a
miniaudio/miniaudio.h view on Meta::CPAN
6.2. Resource Manager Implementation Details
--------------------------------------------
Resources are managed in two main ways:
* By storing the entire sound inside an in-memory buffer (referred to as a data buffer)
* By streaming audio data on the fly (referred to as a data stream)
A resource managed data source (`ma_resource_manager_data_source`) encapsulates a data buffer or
data stream, depending on whether or not the data source was initialized with the
`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. If so, it will make use of a
`ma_resource_manager_data_stream` object. Otherwise it will use a `ma_resource_manager_data_buffer`
miniaudio/miniaudio.h view on Meta::CPAN
determine the required size of the output buffer. frameCountOut should be set to the capacity of pOut. If pOut is NULL, frameCountOut is
ignored.
A return value of 0 indicates an error.
This function is useful for one-off bulk conversions, but if you're streaming data you should use the ma_data_converter APIs instead.
*/
MA_API ma_uint64 ma_convert_frames(void* pOut, ma_uint64 frameCountOut, ma_format formatOut, ma_uint32 channelsOut, ma_uint32 sampleRateOut, const void* pIn, ma_uint64 frameCountIn, ma_format formatIn, ma_uint32 channelsIn, ma_uint32 sampleRateIn);
MA_API ma_uint64 ma_convert_frames_ex(void* pOut, ma_uint64 frameCountOut, const void* pIn, ma_uint64 frameCountIn, const ma_data_converter_config* pConfig);
miniaudio/miniaudio.h view on Meta::CPAN
ma_resource_manager_data_buffer_node* pRootDataBufferNode; /* The root buffer in the binary tree. */
#ifndef MA_NO_THREADING
ma_mutex dataBufferBSTLock; /* For synchronizing access to the data buffer binary tree. */
ma_thread jobThreads[MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT]; /* The threads for executing jobs. */
#endif
ma_job_queue jobQueue; /* Multi-consumer, multi-producer job queue for managing jobs for asynchronous decoding and streaming. */
ma_default_vfs defaultVFS; /* Only used if a custom VFS is not specified. */
ma_log log; /* Only used if no log was specified in the config. */
};
/* Init. */
miniaudio/miniaudio.h view on Meta::CPAN
resume the stream naively. This means that starting the stream requires us to write data to the stream from outside the callback. This
disconnect is something PulseAudio has got seriously wrong - there should only ever be a single source of data delivery, that being the
callback. (I have tried using `pa_stream_flush()` to trigger the write callback to fire, but this just doesn't work for some reason.)
Once you've created the stream, you need to connect it which involves the whole waiting procedure. This is the same process as the context,
only this time you'll poll for the state with `pa_stream_get_status()`. The starting and stopping of a streaming is referred to as
"corking" in PulseAudio. The analogy is corking a barrel. To start the stream, you uncork it, to stop it you cork it. Personally I think
it's silly - why would you not just call it "starting" and "stopping" like any other normal audio API? Anyway, the act of corking is, you
guessed it, asynchronous. This means you'll need our waiting loop as usual. Again, why this asynchronous design is the default is
absolutely beyond me. Would it really be that hard to just make it run synchronously?
MIDI-SoundFont
view release on metacpan or search on metacpan
doc/timidity/playmidi.c view on Meta::CPAN
static int32 ok_nv_sample = 0;
static int ok_nv = 32;
static int old_rate = -1;
#endif
static int midi_streaming = 0;
int volatile stream_max_compute = 500; /* compute time limit (in msec) when streaming */
static int prescanning_flag;
static int32 midi_restart_time = 0;
Channel channel[MAX_CHANNELS];
int max_voices = DEFAULT_VOICES;
Voice *voice = NULL;
doc/timidity/playmidi.c view on Meta::CPAN
else
CLEAR_CHANNELMASK(channel_mute);
}
for (i = 0; i < MAX_CHANNELS; i++)
redraw_controllers(i);
if (midi_streaming && free_instruments_afterwards) {
free_instruments(0);
/* free unused memory */
cnt = free_global_mblock();
if (cnt > 0)
ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
doc/timidity/playmidi.c view on Meta::CPAN
if(cet > current_sample)
{
int rc;
if(midi_streaming!=0){
if ( (cet - current_sample) * 1000 / play_mode->rate > stream_max_compute ) {
kill_all_voices();
/* reset_voices(); */
/* ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY, "play_event: discard %d samples", cet - current_sample); */
current_sample = cet;
doc/timidity/playmidi.c view on Meta::CPAN
if(first)
{
first = 0;
init_mblock(&playmidi_pool);
current_file_info = get_midi_file_info("TiMidity", 1);
midi_streaming=1;
}
else
reuse_mblock(&playmidi_pool);
/* Fill in current_file_info */
MIME-DB
view release on metacpan or search on metacpan
lib/MIME/DB.pm view on Meta::CPAN
$VERSION = 'v1.52.0';
# generation date: 2023-01-31T03:41:54Z
# command: tools\generate.pl
# source url: https://cdn.jsdelivr.net/gh/jshttp/mime-db@v1.52.0/db.json
use constant version => 'v1.52.0';
sub data { {'application/mud+json',{source=>'iana',compressible=>1},'application/vnd.commonspace',{extensions=>['csp'],source=>'iana'},'text/x-handlebars-template',{extensions=>['hbs']},'application/vnd.dbf',{source=>'iana',extensions=>['dbf']},'appl...
1
MIME-Type-FileName
view release on metacpan or search on metacpan
lib/MIME/Type/FileName.pm view on Meta::CPAN
spl application/futuresplash
spr application/x-sprite
sprite application/x-sprite
src application/x-wais-source
ssi text/x-server-parsed-html
ssm application/streamingmedia
sst application/vnd.ms-pki.certstore
step application/step
stl application/sla
stl application/vnd.ms-pki.stl
stl application/x-navistyle
MIME-Types
view release on metacpan or search on metacpan
lib/MIME/types.db view on Meta::CPAN
ssa;text/x-ssa
ssdl;application/x-ssdl+xml
sse;application/vnd.kodak-descriptor
ssf;application/vnd.epson.ssf
ssi;text/x-server-parsed-html
ssm;application/x-streamingmedia
ssml;application/ssml+xml
sst;application/vnd.ms-pki.certstore
ssv;application/vnd.crypto-shade-file
ssvc;application/vnd.crypto-shade-file
ssw;video/vnd.sealed.swf
lib/MIME/types.db view on Meta::CPAN
x-spss-sav;sav,zsav;;
x-spss;sav,sbs,sps,spo,spp;;
x-sql;sql;;
x-ssdl+xml;ssdl;;
x-step;step,stp;;
x-streamingmedia;ssm;;
x-stuffit;sit,sitx;base64;
x-stuffitx;sitx;;
x-subrip;srt;;
x-sv4cpio;sv4cpio;base64;
x-sv4crc;sv4crc;base64;
lib/MIME/types.db view on Meta::CPAN
vnd.ntt-local.sip-ta_tcp_stream;;;
vnd.obn;;;
vnd.ocf+cbor;;;
vnd.oci.image.manifest.v1+json;;;
vnd.oipf.contentaccessdownload+xml;;;
vnd.oipf.contentaccessstreaming+xml;;;
vnd.oipf.cspg-hexbinary;;;
vnd.oipf.dae.svg+xml;;;
vnd.oipf.dae.xhtml+xml;;;
vnd.oipf.mippvcontrolmessage+xml;;;
vnd.oipf.pae.gem;;;
MOP4Import-Declare
view release on metacpan or search on metacpan
psgi.errors
psgi.multithread
psgi.multiprocess
psgi.run_once
psgi.nonblocking
psgi.streaming
psgix.session
psgix.session.options
psgix.logger
/;
}
MP3-Icecast
view release on metacpan or search on metacpan
}
=head1 ABSTRACT
MP3::Icecast supports streaming Icecast protocol over socket
or other filehandle (including STDIN). This is useful for writing
a streaming media server.
MP3::Icecast also includes support for generating M3U and PLSv2
playlist files. These are common formats supported by most modern
media players, including XMMS, Windows Media Player 9, and Winamp.
third argument is given, in which case ->print() is
called on the second argument. An IO::Handle or
Apache instance will work here.
Returns : true on success, false on failure
Args : 1) system path to the file to stream
2) offset in file to start streaming
3) (optional) object to call ->print() on, rather
than printing to STDOUT
=cut
MPEG-Audio-Frame
view release on metacpan or search on metacpan
lib/MPEG/Audio/Frame.pm view on Meta::CPAN
=head1 DESCRIPTION
A very simple, pure Perl module which allows parsing out data from mp3 files,
or streams, and chunking them up into different frames. You can use this to
accurately determine the length of an mp3, filter nonaudio data, or chunk up
the file for streaming via datagram. Virtually anything is possible.
=head1 MPEG FORMAT SUPPORT
L<MPEG::Audio::Frame> supports various types of MPEG data.
MQdb
view release on metacpan or search on metacpan
lib/MQdb/DBStream.pm view on Meta::CPAN
MQdb::DBStream - DESCRIPTION of Object
=head1 SYNOPSIS
A simplified object to manage a collection of information related to streaming data from
a database. at least with MYSQL, the perl driver does odd caching so to stream one
needs to create a new database connection in order to stream
=head1 DESCRIPTION
lib/MQdb/DBStream.pm view on Meta::CPAN
=head2 set_stream_useresult_behaviour
Description : sets a global behaviour for all DBStreams.
setting use_result to "on" will leave the results on the database and
will keep the database connection open durring streaming.
Both methods have similar speed performance, but keeping the results
on the database server means the client uses essentially no memory.
The risk of turning this on is that the the database connection remains open
and there is risk of it timing out if processing takes a long time to stream all data.
When turned off, the entire result set is transfered in bulk to the driver (DBD::mysql)
and streaming happens from the underlying driver code and the perl code layer.
Default is "off" since this is safer but one risks needing lots of memory on the client.
Parameter[1] : 1 or "y" or "on" turns the use_result on and keeps the database connection open
Returntype : none
Exceptions : none
Example : MQdb::DBStream->set_stream_useresult_behaviour(1);
lib/MQdb/DBStream.pm view on Meta::CPAN
=head2 stream_database
Description: this is an internal system method.
Needs to have two database connections open, one for the active
stream handle, and one for lazy-loading additional data on the returned
objects. This is used to set the database which is the one streaming objects
Arg (1) : $database (MQdb::Database) for setting
Returntype : MQdb::Database
Exceptions : none
Callers : MQdb::MappedQuery
Mac-Carbon
view release on metacpan or search on metacpan
AppleEvents/AppleEvents.xs view on Meta::CPAN
MODULE = Mac::AppleEvents PACKAGE = AEStream
=head2 AEStream
The Apple Event Gizmos streams approach uses a streaming model for building
a sequence of descriptors.
=over 4
=item new AEStream
AppleEvents/AppleEvents.xs view on Meta::CPAN
stream
RETVAL
=item Abort STREAM
Abort the streaming process, and close it out.
$stream->Abort;
=cut
MacOSRet
Mac-Errors
view release on metacpan or search on metacpan
lib/Mac/Errors.pm view on Meta::CPAN
sub errAEDuplicateHandler { -1736 }
=item errAEStreamBadNesting
nesting violation while streaming
=cut
sub errAEStreamBadNesting { -1737 }
lib/Mac/Errors.pm view on Meta::CPAN
=cut
sub noMemoryNodeFailedInitialize { -30552 }
=item streamingNodeNotReadyErr
=cut
sub streamingNodeNotReadyErr { -30553 }
=item qtvrLibraryLoadErr
=cut
Mail-Make
view release on metacpan or search on metacpan
lib/Mail/Make.pm view on Meta::CPAN
These methods delegate to L<Mail::Make::SMIME>, which requires L<Crypt::SMIME> (an XS module wrapping OpenSSL C<libcrypto>). All certificates and keys must be supplied in PEM format, either as file paths or as PEM strings.
=head2 Memory usage
All three methods load the complete serialised message into memory before performing any cryptographic operation. This is a fundamental constraint imposed by two factors: the L<Crypt::SMIME> API accepts only Perl strings (no filehandle or streaming i...
For typical email messages this is not a concern. If you anticipate very large attachments, consider L<Mail::Make::GPG> instead, which delegates to the C<gpg> command-line tool via L<IPC::Run> and can handle arbitrary message sizes through temporary ...
See L<Mail::Make::SMIME/"MEMORY USAGE AND LIMITATIONS"> for a full discussion.
Mail-SpamAssassin
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)$/,
Markdent
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.
MarpaX-ESLIF
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.
Mason
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;
Mastodon-Client
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
Math-LiveStats
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
Math-SZaru
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,
Math-ThinPlateSpline
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;
Memcached-libmemcached
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
Message-Passing-PSGI
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;
Minima
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;
( run in 0.997 second using v1.01-cache-2.11-cpan-39bf76dae61 )