view release on metacpan or  search on metacpan

bin/classify-mcl-out.pl  view on Meta::CPAN

    categories:
    - label: strict
      description: strict species sampling
      criteria:
      - tax_filter: [ +Latimeria ]
        min_seq_count: 1
        max_seq_count:
        min_org_count:
        max_org_count:
        min_copy_mean:

bin/classify-mcl-out.pl  view on Meta::CPAN

      - tax_filter: [ +Anolis, +Gallus, +Meleagris, +Taeniopygia ]
      - tax_filter: [ +Mammalia ]
    - label: loose
      description: loose species sampling
      criteria:
      - tax_filter: [ +Latimeria ]
      - tax_filter: [ +Protopterus ]
      - tax_filter: [ +Danio, +Oreochromis ]
      - tax_filter: [ +Amphibia, +Amniota ]

=for Euclid: file.type: readable

 view release on metacpan or  search on metacpan

contrib/roary_plots/roary_files/MathJax.js  view on Meta::CPAN

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

if(document.getElementById&&document.childNodes&&document.createElement){if(!(window.MathJax&&MathJax.Hub)){if(window.MathJax){window.MathJax={AuthorConfig:window.MathJax}}else{window.MathJax={}}MathJax.isPacked=true;MathJax.version="2.5";MathJax.fil...

 view release on metacpan or  search on metacpan

scripts/biosql/load_seqdatabase.pl  view on Meta::CPAN

    if(@pipemods) {
        $pipemods[0]->source_stream($seqin);
        $seqin = $pipemods[-1];
    }

    # reset entry counter and timer
    $n_entries = 0;
    $time = time();

    # loop over the stream
    while( my $seq = $seqin->$nextobj ) {

 view release on metacpan or  search on metacpan

t/lib/Test/Harness.pm  view on Meta::CPAN

run all tests with all warnings enabled.

=item C<HARNESS_TIMER>

Setting this to true will make the harness display the number of
milliseconds each test took.  You can also use F<prove>'s C<--timer>
switch.

=item C<HARNESS_VERBOSE>

If true, Test::Harness will output the verbose results of running

 view release on metacpan or  search on metacpan

Bio/DB/GenericWebAgent.pm  view on Meta::CPAN

 Function: return number of seconds to delay between calls to remote db
 Returns : number of seconds to delay
 Args    : none

NOTE: The default delay policy is 3s.  Override in subclasses to
implement delays.  The timer has only second resolution, so the delay
will actually be +/- 1s.

=cut

sub delay_policy {

 view release on metacpan or  search on metacpan

lib/BoardStreams/Client/Manager.pm  view on Meta::CPAN

    # ping
    $config_o->pipe(
        op_map(sub ($config, @) { $config->{pingInterval} - rand() }),
        op_switch_map(sub ($iv, @) {
            rx_timer($iv * rand(), $iv)->pipe(
                op_take_until($self->connected_o->pipe(op_filter(sub { ! $_ }))),
            ),
        }),
    )->subscribe(sub { $self->send({ type => 'ping' }) });

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

src/boost/mpi/python/skeleton_and_content.hpp
src/boost/mpi/request.hpp
src/boost/mpi/skeleton_and_content.hpp
src/boost/mpi/skeleton_and_content_fwd.hpp
src/boost/mpi/status.hpp
src/boost/mpi/timer.hpp
src/boost/mpl/advance.hpp
src/boost/mpl/advance_fwd.hpp
src/boost/mpl/always.hpp
src/boost/mpl/and.hpp
src/boost/mpl/apply.hpp

MANIFEST  view on Meta::CPAN

src/boost/test/utils/runtime/validation.hpp
src/boost/test/utils/trivial_singleton.hpp
src/boost/test/utils/wrap_stringstream.hpp
src/boost/test/utils/xml_printer.hpp
src/boost/throw_exception.hpp
src/boost/timer.hpp
src/boost/token_functions.hpp
src/boost/token_iterator.hpp
src/boost/tokenizer.hpp
src/boost/tr1/detail/config.hpp
src/boost/tr1/detail/config_all.hpp

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

include/boost/thread/recursive_mutex.hpp
include/boost/thread/thread.hpp
include/boost/thread/tss.hpp
include/boost/thread/xtime.hpp
include/boost/throw_exception.hpp
include/boost/timer.hpp
include/boost/token_functions.hpp
include/boost/token_iterator.hpp
include/boost/tokenizer.hpp
include/boost/tuple/detail/tuple_basic.hpp
include/boost/tuple/detail/tuple_basic_no_partial_spec.hpp

 view release on metacpan or  search on metacpan

t/lib/TestBot/SingleSendJoin.pm  view on Meta::CPAN

    # We need to wait until Bot::Backbone has had a chance to instantiate the
    # service before we can work with it.
    $joined->cb(sub {
        $self->_t(
            AnyEvent->timer(after => 1, cb => sub {
                $self->ready->recv;

                #warn "# SENDING\n";
                $self->get_service('test_group')->send_message({
                    text => "!hello " . $self->say_code,

 view release on metacpan or  search on metacpan

lib/Bot/Backbone/Bot.pm  view on Meta::CPAN

=head1 CAVEATS

This thing sort of kind of needs L<POE> to be any kind of useful. However, L<POE> seems to have weird drawbacks. I have some planned work-arounds for this being an explicit and required dependency, but it's there for now.

Second, if you use the Jabber chat service, you need L<AnyEvent>. Mostly, L<AnyEvent> and L<POE> seem to get along, but it's slow and I've found that timers, in particular, just plain don't work quite right.

=head1 AUTHOR

Andrew Sterling Hanenkamp <hanenkamp@cpan.org>

 view release on metacpan or  search on metacpan

root/js/jquery-1.3.2.min.js  view on Meta::CPAN

 * Sizzle CSS Selector Engine - v0.9.3
 *  Copyright 2009, The Dojo Foundation
 *  Released under the MIT, BSD, and GPL Licenses.
 *  More information: http://sizzlejs.com/
 */
(function(){var R=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,L=0,H=Object.prototype.toString;var F=function(Y,U,ab,ac){ab=ab||[];U=U||document;if(U.nodeType!==1&&U.nodeType!==...

 view release on metacpan or  search on metacpan

eg/tutorial-longpoll-02  view on Meta::CPAN

      }
      elsif (my (          $delay,        $msg) = $text =~ m{
            \A /remind \s+ ([1-9]\d*) \s+ (.*)
         }mxs)
      {
         Mojo::IOLoop->timer($delay => sub {
            $bcb->sender->send_message(
               {
                  text => "$peer_name: remember $msg",
                  chat_id => $chat_id,
               }

 view release on metacpan or  search on metacpan

lib/Bot/ChatBots/Role/Poller.pm  view on Meta::CPAN

}

sub schedule {
   my ($self, $interval, @rest) = @_;
   my $poller = $self->poller(@rest);
   Mojo::IOLoop->timer(0 => $poller);
   Mojo::IOLoop->recurring($interval, $poller);
   return $self;
}

1;

 view release on metacpan or  search on metacpan

lib/Bot/Cobalt/Plugin/RSS.pm  view on Meta::CPAN

  };
  
  ## Can create our XML::RSS:Feed now (requires proper hash above):
  $p_heap->{obj} = $self->_create_feed($feedname);

  ## add to timer pool
  my $pool = $self->pending;
  $pool->{$feedname} = {
    LastRun => 0,
  };

lib/Bot/Cobalt/Plugin/RSS.pm  view on Meta::CPAN

    );
  }

  register( $self, 'SERVER', 
    [
      'executed_timer',
      'rssplug_check_timer_pool',
      'rssplug_got_resp',
    ],
  );
  
  $self->{POOLTIMERID} = $core->timer_set( 6, 
    { Event => 'rssplug_check_timer_pool' }
  );
  
  my $count = $self->list_feed_names;
  logger->info("Loaded - $VERSION - watching $count feeds");  
  

lib/Bot/Cobalt/Plugin/RSS.pm  view on Meta::CPAN

  

sub Cobalt_unregister {
  my ($self, $core) = splice @_, 0, 2;
  
  $core->timer_del($self->{POOLTIMERID});
  $core->timer_del($_) for keys %{$self->{MSGTIMERS}};
  
  delete $self->{HEAP};
  
  logger->info("Unloaded");
  
  return PLUGIN_EAT_NONE
}

sub Bot_executed_timer {
  my ($self, $core) = splice @_, 0, 2;
  my $id = ${ $_[0] };
  delete $self->{MSGTIMERS}->{$id};
  return PLUGIN_EAT_NONE
}

sub Bot_rssplug_check_timer_pool {
  my ($self, $core) = splice @_, 0, 2;
  
  my $pool = $self->pending;
  
  ## check timestamps on pool (keyed on name)
  ## if ts is up, execute _request, schedule new
  for my $feedname (keys %$pool) {
    my $feedmeta  = $self->get_feed_meta($feedname)
                    || return PLUGIN_EAT_NONE;
    my $thistimer = $pool->{$feedname};
    my $lastts    = $thistimer->{LastRun} || 0;
    my $delay     = $feedmeta->{delay};
    
    if (time - $lastts >= $delay) {
      $self->_request($feedname);
      $thistimer->{LastRun} = time;
    }
  }

  $self->{POOLTIMERID} = $core->timer_set( 3, 
    { Event => 'rssplug_check_timer_pool' }
  );
    
  return PLUGIN_EAT_NONE
}

lib/Bot/Cobalt/Plugin/RSS.pm  view on Meta::CPAN

    CONTEXT: for my $context (keys %$a_heap) {
      my $irc = irc_object($context) || next CONTEXT;
      
      for my $channel ( @{ $a_heap->{$context} } ) {
        my $tid = core()->timer_set( 1 + $spcount,
          {
           Type => 'msg',
           Context => $context,
           Target  => $channel,
           Text    => $str,

 view release on metacpan or  search on metacpan

lib/Bot/Cobalt/Plugin/Weather.pm  view on Meta::CPAN

    ],
  );

  register( $self, SERVER =>
    'public_cmd_wx',
    'wx_timer_expire_item',
  );

  logger->info("Loaded: wx");

  PLUGIN_EAT_NONE
}

sub Cobalt_unregister {
  my ($self, $core) = splice @_, 0, 2;
  logger->info("Shutting down POEx::Weather::OpenWeatherMap ...");
  $core->timer_del_alias( $core->get_plugin_alias($self) );
  $self->{location} = +{};
  $self->pwx->stop if $self->pwx;
  logger->info("wx unloaded");
  PLUGIN_EAT_NONE
}

lib/Bot/Cobalt/Plugin/Weather.pm  view on Meta::CPAN

  . ", low of ${temp_lo_f}F/${temp_lo_c}C"
  . ", wind $winddir at ${wind}mph"
  . "; $terse: $verbose"
}

sub Bot_wx_timer_expire_item {
  my ($self, $core) = splice @_, 0, 2;
  my $context = ${ $_[0] };
  my $nick    = ${ $_[1] };
  return unless exists $self->{location}->{$context};
  delete $self->{location}->{$context}->{$nick};

lib/Bot/Cobalt/Plugin/Weather.pm  view on Meta::CPAN

      return PLUGIN_EAT_NONE
    }
  } else {
    $location = join ' ', @parts;
    $loc->{ $context }->{ $lower } = $location;
    $core->timer_set( 180,
      +{
        Event => 'wx_timer_expire_item',
        Args  => [ $context, $lower ],
        Alias => $core->get_plugin_alias($self),
      }
    );
  }

 view release on metacpan or  search on metacpan

lib/Bot/Cobalt.pm  view on Meta::CPAN

=head2 Included plugins

The example C<etc/plugins.conf> installed by C<cobalt2-installer> has 
most of these:

L<Bot::Cobalt::Plugin::Alarmclock> -- IRC highlight timers

L<Bot::Cobalt::Plugin::Auth> -- User authentication

L<Bot::Cobalt::Plugin::Games> -- Simple IRC games

lib/Bot/Cobalt.pm  view on Meta::CPAN

L<Bot::Cobalt::Plugin::Master> -- Simple bot control from IRC

L<Bot::Cobalt::Plugin::PluginMgr> -- Load/unload plugins from IRC

L<Bot::Cobalt::Plugin::RDB> -- "Random stuff" databases for quotebots 
or randomized chatter on a timer

L<Bot::Cobalt::Plugin::Extras::CPAN> -- Query MetaCPAN and 
L<Module::CoreList>

L<Bot::Cobalt::Plugin::Extras::DNS> -- DNS lookups

 view release on metacpan or  search on metacpan

examples/lib/Jabbot/Module/Replier.pm  view on Meta::CPAN

use AnyEvent;

sub init
{
    my ($self, $cl, $jid) = @_;
    $self->{timer} = AnyEvent->timer (after => 5, interval => 10, cb => sub {
        $self->timer($cl,$jid);
     });
    return 0;
}

sub timer
{
    #do something good
}

sub message {

 view release on metacpan or  search on metacpan

lib/Bot/Net/Test.pm  view on Meta::CPAN

=head1 POE STATES

=head2 on _start

Sets up a timer which kills the whole test if it doesn't receive any messages within 30 seconds.

If you have a test that may run for longer than 30 seconds, make sure your events yield "something_happened":

  on bot message_to_me => run {
      yield 'something_happened';

 view release on metacpan or  search on metacpan

lib/Bot/Pastebot/Client/Irc.pm  view on Meta::CPAN

          $kernel->alias_set( "irc_client_$server" );
          $irc->yield( register => 'all' );

          $heap->{server_index} = 0;

          # Keep-alive timer.
          $kernel->delay( autoping => 300 );

          $kernel->yield( 'connect' );
        },

 view release on metacpan or  search on metacpan

lib/Bot/Telegram.pm  view on Meta::CPAN

  $self -> log -> warn("Update processing failed: $err");
};

has [qw/api current_update polling_config/];
has [qw/_polling
        _polling_timer
        _polling_interval
        _polling_request_id/
    ];

has callbacks => sub { {} };

lib/Bot/Telegram.pm  view on Meta::CPAN

    # In synchronous mode, it's enough to simply clear state
    return $self -> _polling_interval(undef)
      unless $agent -> isa('Mojo::UserAgent')
      and $self -> is_async;

    # In asynchronous mode, we also need to cancel existing timers
    for (my $loop = Mojo::IOLoop -> singleton) {
      $loop -> remove($self -> _polling_request_id);
      $loop -> remove($self -> _polling_timer)
        if $self -> _polling_timer; # if another request is scheduled, cancel it
    }

    # Reset state
    $self -> _polling_request_id(undef)
          -> _polling_interval(undef)
          -> _polling_timer(undef);
  }

  $self
}

lib/Bot/Telegram.pm  view on Meta::CPAN

  return unless $self -> is_polling;
  $self -> log -> trace('still polling, scheduling another iteration...');

  if ($async) {
    my $tid = Mojo::IOLoop -> timer(
      $retry_after // $self -> _polling_interval,
      sub { $self -> tap(sub { $self -> log -> trace("it's polling time!") })
                  -> _poll });

    $self -> _polling_timer($tid);
  } else {
    my $d = $retry_after // $self -> _polling_interval;

    # Sleep
    $self -> ioloop -> timer($d, sub { $self -> ioloop -> stop });
    $self -> ioloop -> start;
    $self -> log -> trace("it's polling time!");

    $self -> _poll;
  }

lib/Bot/Telegram.pm  view on Meta::CPAN

=item interval

Interval in seconds between polling requests.

Floating point values are accepted (timers are set using L<Mojo::IOLoop/"timer">).

Default value is 0.3 (300ms).

=back

 view release on metacpan or  search on metacpan

root/static/javascript/jquery.3.3.1.min.js  view on Meta::CPAN

/*! jQuery v3.3.1 | (c) JS Foundation and other contributors | jquery.org/license */
!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof windo...

 view release on metacpan or  search on metacpan

ocip_html/OCISchemaDataTypes.xsd.html  view on Meta::CPAN

</td>
</tr>
<tr xmlns="">
<th>Documentation</th>
<td>
        The timer to start when an invitation is sent to a device associated with a trunk group.
      </td>
</tr>
<tr>
<th>Application Data</th>
<td>

 view release on metacpan or  search on metacpan

t/event-loop/mojo.t  view on Meta::CPAN

        or plan skip_all => 'Future::Mojo or Mojo::IOLoop support not available';
}

subtest 'multi-worker concurrency' => sub {
    my $loop   = Mojo::IOLoop->singleton;
    my $code   = sub { Future::Mojo->new_timer($loop, 0) };
    my $broker = Broker::Async->new(
        workers => [ ($code)x 2 ],
    );

    test_event_loop($broker, [1 .. 5], 'mojo');
};

subtest 'per worker concurrency' => sub {
    my $loop   = Mojo::IOLoop->singleton;
    my $code   = sub { Future::Mojo->new_timer($loop, 0) };
    my $broker = Broker::Async->new(
        workers => [{code => $code, concurrency => 2}],
    );

    test_event_loop($broker, [1 .. 5], 'mojo');

 view release on metacpan or  search on metacpan

t/test1.xml  view on Meta::CPAN

    this.onTimerEvent();
  },

  stop: function() {
    this.updater.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },

  updateComplete: function(request) {
    if (this.options.decay) {
      this.decay = (request.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

      this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this),
      this.decay * this.frequency * 1000);
  },

  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);

 view release on metacpan or  search on metacpan

META.json  view on Meta::CPAN

   "release_status" : "stable",
   "resources" : {
      "bugtracker" : {
         "web" : "https://github.com/jonasbn/bdkpst/issues"
      },
      "homepage" : "https://jonasbn.github.io/perl-test-timer/",
      "repository" : {
         "type" : "git",
         "url" : "https://github.com/jonasbn/bdkpst.git",
         "web" : "https://github.com/jonasbn/bdkpst"
      }

 view release on metacpan or  search on metacpan

examples/web/Scripts/jquery-1.4.4.min.js  view on Meta::CPAN

if(E.ActiveXObject)c.ajaxSettings.xhr=function(){if(E.location.protocol!=="file:")try{return new E.XMLHttpRequest}catch(a){}try{return new E.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}};c.support.ajax=!!c.ajaxSettings.xhr();var ea={},vb=/^(?:toggle...
3),a,b,d);else{d=0;for(var e=this.length;d<e;d++){a=this[d];b=a.style.display;if(!c.data(a,"olddisplay")&&b==="none")b=a.style.display="";b===""&&c.css(a,"display")==="none"&&c.data(a,"olddisplay",qa(a.nodeName))}for(d=0;d<e;d++){a=this[d];b=a.style....
d)}for(a=0;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b,d){var e=typeof a==="boolean";if(c.isFunction(a)&&c.isFunction(b))this._toggle.apply(this,arguments);else a==null||e?this.each(function(){var f=e?a:...
d,e);if(c.isEmptyObject(a))return this.each(f.complete);return this[f.queue===false?"each":"queue"](function(){var h=c.extend({},f),l,k=this.nodeType===1,o=k&&c(this).is(":hidden"),x=this;for(l in a){var r=c.camelCase(l);if(l!==r){a[r]=a[l];delete a[...
"inline")this.style.display="inline-block";else{this.style.display="inline";this.style.zoom=1}else this.style.display="inline-block"}if(c.isArray(a[l])){(h.specialEasing=h.specialEasing||{})[l]=a[l][1];a[l]=a[l][0]}}if(h.overflow!=null)this.style.ove...
1)/J.cur()*I;c.style(x,A,I+g)}if(w[1])L=(w[1]==="-="?-1:1)*L+I;J.custom(I,L,g)}else J.custom(I,C,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);this.each(function(){for(var e=d.length-1;e>=0;e--)if(d[e].elem===this){b&&d[e]...
d,e,f)}});c.extend({speed:function(a,b,d){var e=a&&typeof a==="object"?c.extend({},a):{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};e.duration=c.fx.off?0:typeof e.duration==="number"?e.duration:e.duration in c...
Math.PI)/2+0.5)*e+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||c.fx.step._d...
var f=this,h=c.fx;this.startTime=c.now();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;this.pos=this.state=0;e.elem=this.elem;if(e()&&c.timers.push(e)&&!ba)ba=setInterval(h.tick,h.interval)},show:function(){this.options.ori...
this.custom(this.cur(),0)},step:function(a){var b=c.now(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var e in this.options.curAnim)if(this.optio...
this.options.show)for(var l in this.options.curAnim)c.style(this.elem,l,this.options.orig[l]);this.options.complete.call(this.elem)}return false}else{a=b-this.startTime;this.state=a/this.options.duration;b=this.options.easing||(c.easing.swing?"swing"...
c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||c.fx.stop()},interval:13,stop:function(){clearInterval(ba);ba=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){...
b.elem}).length};var xb=/^t(?:able|d|h)$/i,Ia=/^(?:body|html)$/i;c.fn.offset="getBoundingClientRect"in t.documentElement?function(a){var b=this[0],d;if(a)return this.each(function(l){c.offset.setOffset(this,a,l)});if(!b||!b.ownerDocument)return null;...
h.scrollTop||b.scrollTop)-(h.clientTop||b.clientTop||0),left:d.left+(f.pageXOffset||c.support.boxModel&&h.scrollLeft||b.scrollLeft)-(h.clientLeft||b.clientLeft||0)}}:function(a){var b=this[0];if(a)return this.each(function(x){c.offset.setOffset(this,...
for(var k=b.offsetTop,o=b.offsetLeft;(b=b.parentNode)&&b!==l&&b!==h;){if(c.offset.supportsFixedPosition&&d.position==="fixed")break;d=f?f.getComputedStyle(b,null):b.currentStyle;k-=b.scrollTop;o-=b.scrollLeft;if(b===e){k+=b.offsetTop;o+=b.offsetLeft;...
parseFloat(d.borderTopWidth)||0;o+=parseFloat(d.borderLeftWidth)||0}d=d}if(d.position==="relative"||d.position==="static"){k+=l.offsetTop;o+=l.offsetLeft}if(c.offset.supportsFixedPosition&&d.position==="fixed"){k+=Math.max(h.scrollTop,l.scrollTop);o+...
height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;pa...

 view release on metacpan or  search on metacpan

t/testlib/StatusStorage/AEDelayed.pm  view on Meta::CPAN

    my ($self, @args) = @_;
    my $method;
    $method = (caller(1))[3];
    $method =~ s/^.*:://g;
    my $delay = $self->{delay_sec} || 0;
    my $w; $w = AnyEvent->timer(
        after => $delay,
        cb => sub {
            undef $w;
            $self->{backend}->$method(@args);
        }

 view release on metacpan or  search on metacpan

t/include/input.h  view on Meta::CPAN

 * In-kernel definitions.
 */

#include <linux/device.h>
#include <linux/fs.h>
#include <linux/timer.h>
#include <linux/mod_devicetable.h>

#define NBITS(x) (((x)/BITS_PER_LONG)+1)
#define BIT(x)	(1UL<<((x)%BITS_PER_LONG))
#define LONG(x) ((x)/BITS_PER_LONG)

t/include/input.h  view on Meta::CPAN

	void *keycode;

	struct ff_device *ff;

	unsigned int repeat_key;
	struct timer_list timer;

	int state;

	int sync;

 view release on metacpan or  search on metacpan

src/sparse-0.4.4/perl/t/include/block/aio.h  view on Meta::CPAN

#include "qemu/typedefs.h"
#include "qemu-common.h"
#include "qemu/queue.h"
#include "qemu/event_notifier.h"
#include "qemu/thread.h"
#include "qemu/timer.h"

typedef struct BlockDriverAIOCB BlockDriverAIOCB;
typedef void BlockDriverCompletionFunc(void *opaque, int ret);

typedef struct AIOCBInfo {

src/sparse-0.4.4/perl/t/include/block/aio.h  view on Meta::CPAN

    GArray *pollfds;

    /* Thread pool for performing work and receiving completion callbacks */
    struct ThreadPool *thread_pool;

    /* TimerLists for calling timers - one per clock type */
    QEMUTimerListGroup tlg;
};

/**
 * aio_context_new: Allocate a new AioContext.

src/sparse-0.4.4/perl/t/include/block/aio.h  view on Meta::CPAN

                             IOHandler *io_write,
                             void *opaque);
#endif

/**
 * aio_timer_new:
 * @ctx: the aio context
 * @type: the clock type
 * @scale: the scale
 * @cb: the callback to call on timer expiry
 * @opaque: the opaque pointer to pass to the callback
 *
 * Allocate a new timer attached to the context @ctx.
 * The function is responsible for memory allocation.
 *
 * The preferred interface is aio_timer_init. Use that
 * unless you really need dynamic memory allocation.
 *
 * Returns: a pointer to the new timer
 */
static inline QEMUTimer *aio_timer_new(AioContext *ctx, QEMUClockType type,
                                       int scale,
                                       QEMUTimerCB *cb, void *opaque)
{
    return timer_new_tl(ctx->tlg.tl[type], scale, cb, opaque);
}

/**
 * aio_timer_init:
 * @ctx: the aio context
 * @ts: the timer
 * @type: the clock type
 * @scale: the scale
 * @cb: the callback to call on timer expiry
 * @opaque: the opaque pointer to pass to the callback
 *
 * Initialise a new timer attached to the context @ctx.
 * The caller is responsible for memory allocation.
 */
static inline void aio_timer_init(AioContext *ctx,
                                  QEMUTimer *ts, QEMUClockType type,
                                  int scale,
                                  QEMUTimerCB *cb, void *opaque)
{
    timer_init(ts, ctx->tlg.tl[type], scale, cb, opaque);
}

#endif