Result:
found more than 697 distributions - search limited to the first 2001 files matching your query
( run in 2.882 )
ArrayData-Lingua-Word-EN-Wordle
view release on metacpan or search on metacpan
lib/ArrayData/Lingua/Word/EN/Wordle.pm view on Meta::CPAN
tilly
tilth
tilts
timbo
timed
timer
times
timid
timon
timps
tinas
ArrayData-Word-EN-Enable
view release on metacpan or search on metacpan
lib/ArrayData/Word/EN/Enable.pm view on Meta::CPAN
antimaterialists
antimatter
antimatters
antimechanist
antimechanists
antimere
antimeres
antimerger
antimetabolic
antimetabolics
antimetabolite
antimetabolites
antimetaphysical
lib/ArrayData/Word/EN/Enable.pm view on Meta::CPAN
timeouts
timepiece
timepieces
timepleaser
timepleasers
timer
timers
times
timesaver
timesavers
timesaving
timescale
Articulate
view release on metacpan or search on metacpan
t/public/javascripts/jquery.js view on Meta::CPAN
/*! jQuery v1.11.2 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */
!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this...
return!0}function Q(a,b,d,e){if(m.acceptData(a)){var f,g,h=m.expando,i=a.nodeType,j=i?m.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||m.guid++:h),j[k]||(j[k]=i?{}:{toJSON:m.noop}),("o...
}m.Tween=Zb,Zb.prototype={constructor:Zb,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(m.cssNumber[c]?"":"px")},cur:function(){var a=Zb.propHooks[this....
Aspect-Library-Timer
view release on metacpan or search on metacpan
lib/Aspect/Library/Timer.pm view on Meta::CPAN
=pod
=head1 NAME
Aspect::Library::Timer - Predefined timer pointcut
=head1 SYNOPSIS
use Aspect;
lib/Aspect/Library/Timer.pm view on Meta::CPAN
sleep 1;
}
=head1 DESCRIPTION
C<Aspect::Library::Timer> provides support for simple timers aspects.
=head1 SUPPORT
Bugs should be reported via the CPAN bug tracker at
Aspect
view release on metacpan or search on metacpan
lib/Aspect/Library/Listenable.pm view on Meta::CPAN
=over 4
=item *
A timer that allows registration of listeners. They will receive events
when the timer fires.
=item *
In an MVC application, as a mechanism for registering views as listeners
of models. Then when models change, views receive events, which they
Asterisk-AMI
view release on metacpan or search on metacpan
lib/Asterisk/AMI.pm view on Meta::CPAN
Callbacks only work if we are processing packets, therefore you must be running an event loop. Alternatively, we run
mini-event loops for our blocking calls (e.g. action(), get_action()), so in theory if you set callbacks and then
issue a blocking call those callbacks should also get triggered. However this is an unsupported scenario.
Timeouts are done using timers and they are set as soon as you send the object. Therefore if you send an action with a
timeout and then monkey around for a long time before getting back to your event loop (to process input) you can time
out before ever even attempting to receive the response.
A very contrived example:
$astman->send_action({ Action => 'Ping' }, \&somemethod, 3);
lib/Asterisk/AMI.pm view on Meta::CPAN
#Weaken reference for use in anonsub
weaken($self);
#Set keepalive
$self->{CONFIG}->{KEEPALIVE} = AE::timer($self->{CONFIG}->{KEEPALIVE}, $self->{CONFIG}->{KEEPALIVE}, sub { $self->_send_keepalive }) if ($self->{CONFIG}->{KEEPALIVE});
return 1;
}
#Handles connection failures (includes login failure);
lib/Asterisk/AMI.pm view on Meta::CPAN
};
#Make sure event loop is up to date in case of sleeps
AE::now_update;
$self->{CALLBACKS}->{$id}->{'timer'} = AE::timer $timeout, 0, $self->{CALLBACKS}->{$id}->{'timeout'};
}
return $process->recv;
}
lib/Asterisk/AMI.pm view on Meta::CPAN
$self->{CALLBACKS}->{$id}->{'cb'} = $callback;
#Variable to return with Callback
$self->{CALLBACKS}->{$id}->{'store'} = $store;
}
#Start timer for timeouts
if ($timeout && defined $self->{CALLBACKS}->{$id}) {
$self->{CALLBACKS}->{$id}->{'timeout'} = sub {
my $response = $self->{RESPONSEBUFFER}->{$id};
my $cb = $self->{CALLBACKS}->{$id}->{'cb'};
my $st = $self->{CALLBACKS}->{$id}->{'store'};
lib/Asterisk/AMI.pm view on Meta::CPAN
delete $self->{CALLBACKS}->{$id};
delete $self->{EXPECTED}->{$id};
delete $self->{PRELOGIN}->{$id};
$cb->($self, $response, $st);;
};
$self->{CALLBACKS}->{$id}->{'timer'} = AE::timer $timeout, 0, $self->{CALLBACKS}->{$id}->{'timeout'};
}
return $id;
}
lib/Asterisk/AMI.pm view on Meta::CPAN
if ($timeout) {
#Make sure event loop is up to date in case of sleeps
AE::now_update;
$self->{CALLBACKS}->{'EVENT'}->{'timer'} = AE::timer $timeout, 0, $self->{CALLBACKS}->{'EVENT'}->{'timeout'};
}
return $process->recv;
}
Asterisk-CoroManager
view release on metacpan or search on metacpan
lib/Asterisk/CoroManager.pm view on Meta::CPAN
}
);
# Check connection every 5th second..
$astman->{clock_check}
= AnyEvent->timer( after => 5,
interval => 5,
cb => sub {
async{ $astman->check_connection }
},
);
Astro-FITS-CFITSIO
view release on metacpan or search on metacpan
OUTPUT:
nrows
status
int
ffgstm(timestr,timeref,status)
char * timestr = NO_INIT
int timeref = NO_INIT
int status
ALIAS:
Astro::FITS::CFITSIO::fits_get_system_time = 1
CODE:
timestr = get_mortalspace(20,TBYTE); /* YYYY-MM-DDThh:mm:ss */
RETVAL=ffgstm(timestr,&timeref,&status);
if (ST(1) != &PL_sv_undef) sv_setiv(ST(1),timeref);
OUTPUT:
timestr
status
RETVAL
Astro-SunTime
view release on metacpan or search on metacpan
lib/Astro/SunTime.pm view on Meta::CPAN
$S = $S / sqrt(-$S * $S + 1);
$S = $A - atan2($S, 1);
$S = $D - $S if $type eq 'rise';
my $T = $S + $P - 0.0172028 * $K - 1.73364; # Local apparent time
my $U = $T - $F; # Universal timer
my $V = $U + $G; # Wall clock time
$V = &normalize($V, $D);
$V = $V * 3.81972;
my $hour = int($V);
Astro-Sunrise
view release on metacpan or search on metacpan
doc/notes-astronomiques.pod view on Meta::CPAN
Q : Dans le cas de la transition avec la période de nuit polaire,
la course du Soleil est tangente à la ligne d'horizon, comme pour
la transition avec la période du Soleil de minuit. Alors pourquoi,
dans ce cas, conseilles-tu quand même l'algorithme de base ?
R : L'algorithme de base et l'algorithme précis essaient tous deux d'estimer
la longitude écliptique et la hauteur du Soleil au midi solaire virtuel correspondant
à l'heure du coucher du Soleil. Mais alors que l'algorithme précis utilise
la vitesse réelle du Soleil, qui varie de 0,9552°/j à 1,0166°/j, l'algorithme
de base utilise une vitesse moyenne de 0,9856°/j, ce qui fait une erreur
de ±0,0310°/j. À l'occasion de la transition entre jour+nuit et le Soleil
Async-ContextSwitcher
view release on metacpan or search on metacpan
for my $i (1 .. $how_many) {
Async::ContextSwitcher->new( test => $i );
my $w;
$w = AnyEvent->timer( after => rand()*0.1, cb => cb_w_context {
$w = undef;
my $cb = cb_w_context {
is context->{test}, $i, "good $i";
$cv->send if --$how_many == 0;
Async-Defer
view release on metacpan or search on metacpan
$d = Async::Defer->new();
$d->do(sub{
my ($d, $n) = @_;
$n++;
$d->{t} = AE::timer 0.01, 0, sub{ $d->done($n) };
});
$d->do(sub{
my ($d, $n) = @_;
$n+=10;
$result = $n;
$d->done($n);
});
$t = AE::timer 0.01, 0, sub{ $d->run(undef, 3) };
$tx= AE::timer 0.5, 0, sub{ $cv->send };
$result = undef;
$cv = AE::cv; $cv->recv;
is $result, 14, 'handle correctly both sync and async functions';
$p = Async::Defer->new();
Async-Event-Interval
view release on metacpan or search on metacpan
lib/Async/Event/Interval.pm view on Meta::CPAN
B<Note>: You can set L<immediate()|/immediate($value)> to have the callback fire
immediately on C<start()>, rather than waiting for the first interval.
=head2 start(@params)
Starts the event timer. Each time the interval is reached, the event callback
is executed.
Parameters:
@params
Async-Microservice
view release on metacpan or search on metacpan
lib/Async/Microservice/Time.pm view on Meta::CPAN
This is the only response method processed in parallel (the other ones are
pure CPU-bound) that sleeps for a given (or random) number of seconds and
only then returns the request response with when it started and how long
it took. Normally this is the same as what is in the duration parameter,
but in case the server is overloaded with requests, the event loop may call the
timer handler much later than the duration. Try:
ab -n 1000 -c 500 http://localhost:8085/v1/sleep?duration=3
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 259 432.8 21 1033
Async-Redis
view release on metacpan or search on metacpan
examples/bulk-insert/app.pl view on Meta::CPAN
$state->{issued} += scalar @futures;
await Future->needs_all(@futures);
$state->{confirmed} += scalar @futures;
$state->{batches}++;
# Give timer-based tasks a scheduling point between large batches.
await Future::IO->sleep(0);
}
return;
}
Async-Template
view release on metacpan or search on metacpan
lib/Async/Template.pm view on Meta::CPAN
$cv->begin;
my $tt2 = Async::Template->new({
DONE => sub{ my $output = shift; $cv->end; },
}) || die Async::Template->error();
$cv->begin;
AnyEvent->timer(after => 10, cb => sub { $cv->end; });
$cv->recv
# usage in perl code for async processes
Async-Trampoline
view release on metacpan or search on metacpan
lib/Async/Trampoline.pm view on Meta::CPAN
While Asyncs are Future-like, you cannot resolve an Async explicitly.
Check out the L<Future|Future> module instead.
This module does not implement an event loop.
The C<run_until_completion()> function does run a dispatch loop,
but there is no concept of events, I/O, or timers.
Check out the L<IO::Async|IO::Async> module instead.
This module is not thread-aware.
Handling the same Async on multiple threads is undefined behaviour.
Async-Util
view release on metacpan or search on metacpan
lib/Async/Util.pm view on Meta::CPAN
Examples using AnyEvent:
use AnyEvent;
use Async::Util qw(amap);
my @timers;
my $delayed_double = sub {
my ($input, $cb) = @_;
push @timers, AnyEvent->timer(after => 2, cb => sub {
$cb->($input*2);
});
};
my $cv = AE::cv;
lib/Async/Util.pm view on Meta::CPAN
achain(
input => 2,
steps => [
sub {
my ($input, $cb) = @_;
push @timers, AnyEvent->timer(
after => 0,
cb => sub { $cb->($input+1) },
);
},
sub {
my ($input, $cb) = @_;
push @timers, AnyEvent->timer(
after => 0,
cb => sub { $cb->($input * 2) },
);
},
],
At
view release on metacpan or search on metacpan
eg/mojo_oauth.pl view on Meta::CPAN
say ' Description: ' . ( $profile->{description} // '[no description]' );
$c->render( text => '<h1>Success!</h1><p>You are authenticated as <b>' .
$profile->{displayName} . '</b>.</p><p>You can close this window and check the console.</p>' );
# Gracefully stop the server
Mojo::IOLoop->timer( 1 => sub { exit 0 } );
};
app->start( 'daemon', '-l', 'http://127.0.0.1:' . $port );
=head1 NAME
Audio-Beep
view release on metacpan or search on metacpan
lib/Audio/Beep/Linux/PP.pm view on Meta::CPAN
sound requests to be phrased. If you see Raine, thank him for me.
June 28, email from Peter Tirsek (peter at tirsek dot com):
This number represents the fixed frequency of the original PC XT's
timer chip (the 8254 AFAIR), which is approximately 1.193 MHz. This
number is divided with the desired frequency to obtain a counter value,
that is subsequently fed into the timer chip, tied to the PC speaker.
The chip decreases this counter at every tick (1.193 MHz) and when it
reaches zero, it toggles the state of the speaker (on/off, or in/out),
resets the counter to the original value, and starts over. The end
result of this is a tone at approximately the desired frequency. :)
Audio-LibSampleRate
view release on metacpan or search on metacpan
libsamplerate/examples/audio_out.c view on Meta::CPAN
else if (snd_pcm_status_get_state (status) == SND_PCM_STATE_XRUN)
{ struct timeval now, diff, tstamp ;
gettimeofday (&now, 0) ;
snd_pcm_status_get_trigger_tstamp (status, &tstamp) ;
timersub (&now, &tstamp, &diff) ;
fprintf (stderr, "alsa_write_float xrun: of at least %.3f msecs. resetting stream\n",
diff.tv_sec * 1000 + diff.tv_usec / 1000.0) ;
}
else
Audio-MPEG
view release on metacpan or search on metacpan
if (MAD_RECOVERABLE(stream->error))
err = 0;
if (!err) {
THIS->current_frame++;
THIS->accum_bitrate += header->bitrate / 1000;
mad_timer_add(&THIS->total_duration, header->duration);
}
XSRETURN_YES;
#
# Create PCM stream (in mad_fixed_t type) from decoded frame
double
frame_duration(THIS)
Audio_MPEG_Decode THIS
CODE:
RETVAL = (double)mad_timer_count(THIS->frame->header.duration,
MAD_UNITS_MILLISECONDS) / 1000.0;
OUTPUT:
RETVAL
double
total_duration(THIS)
Audio_MPEG_Decode THIS
CODE:
RETVAL = (double)mad_timer_count(THIS->total_duration,
MAD_UNITS_MILLISECONDS) / 1000.0;
OUTPUT:
RETVAL
unsigned int
Audio-Mad
view release on metacpan or search on metacpan
)],
f => [qw(MAD_F_ONE MAD_F_MIN MAD_F_MAX MAD_F_FRACBITS)],
layer => [qw(MAD_LAYER_I MAD_LAYER_II MAD_LAYER_III)],
mode => [qw(MAD_MODE_SINGLE_CHANNEL MAD_MODE_DUAL_CHANNEL MAD_MODE_JOINT_STEREO MAD_MODE_STEREO)],
option => [qw(MAD_OPTION_HALFSAMPLERATE MAD_OPTION_IGNORECRC)],
timer => [qw(MAD_TIMER_RESOLUTION)],
units => [qw(
MAD_UNITS_11025_HZ MAD_UNITS_12000_HZ MAD_UNITS_16000_HZ
MAD_UNITS_22050_HZ MAD_UNITS_24000_HZ MAD_UNITS_32000_HZ
MAD_UNITS_44100_HZ MAD_UNITS_48000_HZ MAD_UNITS_8000_HZ
MAD_UNITS_CENTISECONDS MAD_UNITS_DECISECONDS MAD_UNITS_HOURS
use Audio::Mad qw(:all);
my $stream = new Audio::Mad::Stream();
my $frame = new Audio::Mad::Frame();
my $synth = new Audio::Mad::Synth();
my $timer = new Audio::Mad::Timer();
my $resample = new Audio::Mad::Resample(44100, 22050);
my $dither = new Audio::Mad::Dither();
my $buffer = join('', <STDIN>);
$stream->buffer($buffer);
=item * :mode
MAD_MODE_SINGLE_CHANNEL MAD_MODE_STEREO
MAD_MODE_DUAL_CHANNEL MAD_MODE_JOINT_STEREO
=item * :timer
MAD_TIMER_RESOLUTION
=item * :units
Audio-MikMod
view release on metacpan or search on metacpan
demo/player-gtk-ipc view on Meta::CPAN
$song_paused->store(0);
my ($song_loaded,$song_playing) = (0,0);
my ($songfile,$songpath,$player_busy);
my ($filelabel,$songlabel,$child,$progress_timer);
my $url = 'http://electricrain.com/';
my $subs = {
'exit' => \&_exit,
'back' => \&_back,
demo/player-gtk-ipc view on Meta::CPAN
my $pbar = Gtk::ProgressBar->new;
$pbar->set_usize(200,20);
$vbox->pack_start($pbar,1,1,0);
$pbar->show;
#$progress_timer = Gtk->timeout_add(100, \&progress_timeout, $pbar);
####################################
# label for currently open file path
$filelabel = Gtk::Label->new('');
$vbox->pack_start($filelabel, FALSE, FALSE, 0);
Audio-Nama
view release on metacpan or search on metacpan
lib/Audio/Nama.pm view on Meta::CPAN
what: Stop recording after the last audio file finishes playing. Can be turned off with limit-run-time_off.
short: lr
parameters: [ <float:additional_seconds> ]
limit_run_time_off:
type: setup
what: Disable the recording stop timer.
short: lro
parameters: none
offset_run:
type: setup
what: Record/play from a mark, rather than from the start, i.e. 0.0 seconds.
lib/Audio/Nama.pm view on Meta::CPAN
? eval "$Audio::Nama::setup->{audio_length} $sign $item{dd}"
: $item{dd};
Audio::Nama::pager( "Run time limit: ", Audio::Nama::heuristic_time($Audio::Nama::setup->{runtime_limit})); 1;
}
limit_run_time_off: _limit_run_time_off {
Audio::Nama::pager( "Run timer disabled");
Audio::Nama::disable_length_timer();
1;
}
offset_run: _offset_run markname {
Audio::Nama::set_offset_run_mark( $item{markname} ); 1
}
lib/Audio/Nama.pm view on Meta::CPAN
If midish is configured to use ALSA (default on Linux systems) then ``filename'' should contain the ALSA sequencer port, as listed by ``aseqdump -l'', (eg. ``28:0'', ``FLUID Synth (qsynth)''). If ``nil'' is given instead of the path, then the por...
ddel devnum
detach device number ``devnum''
dmtcrx devnum
use device number ``devnum'' as MTC source. In this case, midish will relocate, start and stop according to incoming MTC messages. Midish will generate its clock ticks from MTC, meaning that it will run at the same speed as the MTC device. This i...
dmmctx { devnum1 devnum2 ... }
Configure the given devices to transmit MMC start, stop and relocate messages. Useful to control MMC-capable audio applications from midish. By default, devices transmit MMC.
dclktx { devnum1 devnum2 ... }
Configure the given devices to transmit MIDI clock information (MIDI ticks, MIDI start and MIDI stop events). Useful to synchronize an external sequencer to midish.
dclkrx devnum
lib/Audio/Nama.pm view on Meta::CPAN
``mididev'' - show raw MIDI traffic on stderr
``mixout'' - show conflicts in the output MIDI merger
``norm'' - show events in the input normalizer
``pool'' - show pool usage on exit
``song'' - show start/stop events
``timo'' - show timer internal errors
``mem'' - show memory usage
version
Display midish version.
panic
Audio-Play-MPG123
view release on metacpan or search on metacpan
mpg123/system.c view on Meta::CPAN
}
return ret;
}
static unsigned long system_raw_timer_value(unsigned char *buf)
{
unsigned long val;
if(!(buf[0] & 0x1) || !(buf[2] & 0x1) || !(buf[4] & 0x1)) {
if(verbose)
mpg123/system.c view on Meta::CPAN
}
switch( buf[pos] & 0xf0) {
case 0x00:
if(buf[pos] != 0x0f) {
fprintf(stderr,"Ouch ... illegal timer code!\n");
return -1;
}
pos++;
break;
case 0x20:
pi->pts = system_raw_timer_value(buf+pos);
pos += 5;
break;
case 0x30:
pi->pts = system_raw_timer_value(buf+pos);
pos += 5;
if( (buf[pos] & 0xf) != 0x10) {
if(verbose)
fprintf(stderr,"DTS should start with 0x1x!\n");
}
pi->dts = system_raw_timer_value(buf+pos);
pos += 5;
break;
default:
if(verbose)
fprintf(stderr,"Ouch ... illegal timer code!\n");
return -1;
}
Audio-Radio-Sirius
view release on metacpan or search on metacpan
lib/Audio/Radio/Sirius.pm view on Meta::CPAN
PIDs, signal strength, and other information. Calling monitor initiates reads of this data.
Reads happen automatically when commands are executed (for example changing the channel or muting the tuner). Still, monitor generally needs
to be called as often as possible to gather the latest data from the Tuner.
A monitor cycle will take a minimum of one second. If data is received, this timer resets. In other words, monitor may take longer than you anticipate.
The amount of time monitor takes will depend on the C<verbosity> of the tuner.
If no number of cycles is specified, monitor runs one cycle.
B<Note:> As of version 0.02, the cycle parameter is no longer a true count of the number of cycles. The number specified is multiplied by 20.
Audio-SID
view release on metacpan or search on metacpan
=item B<$OBJECT>->B<getSpeed>([SCALAR])
Returns the speed of the song number specified by SCALAR. If no SCALAR is
specified, returns the speed of song #1. Speed can be either 0 (indicating a
vertical blank interrupt (50Hz PAL, 60Hz NTSC)), or 1 (indicating CIA 1 timer
interrupt (default is 60Hz)).
For PlaySID specific files the corresponding bit of I<speed> from SCALAR modulo
32 is returned ("wraparound" behavior for songs > 32).
=item B<$OBJECT>->B<setSpeed>(SCALAR1, SCALAR2)
Changes the speed of the song number specified by SCALAR1 to that of SCALAR2.
SCALAR1 has to be more than 1 and less than the value of the I<songs> field.
SCALAR2 can be either 0 (indicating a vertical blank interrupt (50Hz PAL, 60Hz
NTSC)), or 1 (indicating CIA 1 timer interrupt (default is 60Hz)). An undef is
returned if neither was specified.
For PlaySID specific files if SCALAR1 is greater than 32, the SCALAR1 module 32
bit of the I<speed> field will be set, overwriting whatever value was in that
bit before ("wraparound" behavior for songs > 32).
Audio-StreamGenerator
view release on metacpan or search on metacpan
lib/Audio/StreamGenerator.pm view on Meta::CPAN
my $streamer_sub = $streamer->get_streamer(0.5);
$loop->recurring(0.05 => $streamer_sub);
$loop->start;
Note: event loop will be blocked for up to 0.5 seconds every time the timer is done. The timer/streamer ratio should be sizeable enough for the loop to run smoothly, including the mixing process. This may vary depending on the speed of the machine wh...
=head2 skip
$streamer->skip();
Audio
view release on metacpan or search on metacpan
Data/Data.pm view on Meta::CPAN
=item $copy = $audio->clone
Creates copy of data carrying over sample rate and complex-ness of data.
=item $slice = $audio->timerange($start_time,$end_time);
Returns a time-slice between specified times.
=item $audio->Load($fh)
( run in 2.882 seconds using v1.01-cache-2.11-cpan-85f18b9d64f )