view release on metacpan or  search on metacpan

lib/Devel/Declare/Lexer.pm  view on Meta::CPAN

sub call_lexed
{
    my ($name, $stream) = @_;

    $DEBUG and print STDERR "Checking for callbacks for keyword '$name'\n";
    $DEBUG and print STDERR Dumper($stream) . "\n";

    my $callback = $named_lexed_stack{$name};
    if($callback) {
        $DEBUG and print STDERR "Found callback '$callback' for keyword '$name'\n";

 view release on metacpan or  search on metacpan

lib/Devel/EnforceEncapsulation.pm  view on Meta::CPAN

   eval "{package $dest_pkg; no overload $overloads, 'fallback';}";
   die $EVAL_ERROR if $EVAL_ERROR;
   return;
}

## possible callbacks to be installed via overload ##

sub _deref_overload_croak {
   my $self = shift;

   my $caller_pkg = caller;

 view release on metacpan or  search on metacpan

lib/Devel/Events/Filter/Stringify.pm  view on Meta::CPAN

This filter prevents leaks from happenning when an event logger is used by
simply stringifying all data.

Note that objects that overload stringification will *not* have their
stringification callbacks activated unless C<respect_overloading> is set to a
true value.

=head1 SUBCLASSING

In order ot perform custom dumps of objects that are more descriptive or even

 view release on metacpan or  search on metacpan

lib/Devel/Examine/Subs.pm  view on Meta::CPAN

=back


=head2 C<pre_procs>, C<post_procs>, C<engines>

For development. Returns the list of the respective built-in callbacks.




=head1 PARAMETERS

lib/Devel/Examine/Subs.pm  view on Meta::CPAN

State: Transient

Default: undef

These are mainly used to set up the public methods with the proper callbacks
used by the C<run()> command.

C<engine> and C<pre_proc> take either a single string that contains a valid
built-in callback, or a single code reference of a custom callback.

 view release on metacpan or  search on metacpan

bin/perlbrewise-spec  view on Meta::CPAN

  
  For deserialization there are only two cases to consider: either
  nonstandard tagging was used, in which case C<allow_tags> decides,
  or objects cannot be automatically be deserialized, in which
  case you can use postprocessing or the C<filter_json_object> or
  C<filter_json_single_key_object> callbacks to get some real objects our of
  your JSON.
  
  This section only considers the tagged value case: I a tagged JSON object
  is encountered during decoding and C<allow_tags> is disabled, a parse
  error will result (as if tagged values were not part of the grammar).

 view release on metacpan or  search on metacpan

lib/Devel/Leak/Cb.pm  view on Meta::CPAN

use strict;
use warnings;
}x;
=head1 NAME

Devel::Leak::Cb - Detect leaked callbacks

=head1 VERSION

Version 0.04

lib/Devel/Leak/Cb.pm  view on Meta::CPAN

=head1 EXPORT

Exports a single function: cb {}, which would be rewritten as sub {} when C<$ENV{DEBUG_CB}> is not in effect

If C<DEBUG_CB> > 1 and L<Devel::FindRef> is installed, then output will include reference tree of leaked callbacks

=head1 FUNCTIONS

=head2 cb {}

lib/Devel/Leak/Cb.pm  view on Meta::CPAN

	my $cb = cb 'name' {};
	my $cb = cb "name.$val" {};

=head2 COUNT

	You may call C<Devel::Leak::Cb::COUNT()> Manually to check state. All leaked callbacks will be warned. Noop without C<$ENV{DEBUG_CB}>

=cut

use Devel::Declare ();
use Scalar::Util 'weaken';

 view release on metacpan or  search on metacpan

hash.c  view on Meta::CPAN

    }

    return err;
}

int hash_set_callbacks( hash * h, void *cbd,
                        int ( *cb_add ) ( hash * h, void *d, void **v ),
                        int ( *cb_del ) ( hash * h, void *d, void *v ),
                        int ( *cb_upd ) ( hash * h, void *d, void *ov,
                                          void **nv ) ) {
    h->cbd = cbd;

hash.c  view on Meta::CPAN

        return err;
    }

    /* Iterate through the keys copying entries one at a time. This has the
     * happy side effect of clearing out the garbage left by any deleted keys.
     * Any callbacks that are installed for the original hash won't be in
     * effect on the new hash so there's no need to worry about any side
     * effects they might have. Once the new hash data is moved back into the
     * original hash any callbacks will automatically take effect again.
     */
    key = hash_get_first_key( h, &i, &key_len );
    while ( key ) {
        if ( err =
             hash_put( nh, key, key_len, hash_get( h, key, key_len ) ),

hash.c  view on Meta::CPAN

    else {
        /* Replace an existing entry.
         */
        sl = ( hash_slot * ) ( ( char * )h->buf.buf + s );

        /* If the value is actually changing inform any callbacks */
        if ( sl->v != val ) {
            if ( h->cb_upd ) {
                if ( err =
                     h->cb_upd( h, h->cbd, sl->v, &val ),
                     ERR_None != err ) {

 view release on metacpan or  search on metacpan

lib/Devel/LineTrace.pm  view on Meta::CPAN

    perl -d:LineTrace myscript.pl [args ...]

=head1 DESCRIPTION

This is a class that enables assigning Perl code callbacks to certain
lines in the original code B<without modifying it>.

To do so prepare a file with the following syntax:

    [source_filename]:[line]

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.09 Fri, Sep 23, 2011
    - Close issue #2 - Use BSD::Process maxrss instead of rssize, which was incorrect
    - Out of beta!

0.08 Sun, Jun 26, 2011
    - Close issue #1 - callbacks could cause memory growth and incorrect results

0.07 Sat, Jun 11, 2011
    - Better test case to ensure memory traces are detected

0.06 Fri, Jun 10, 2011

 view release on metacpan or  search on metacpan

lib/Devel/NYTProf.pm  view on Meta::CPAN

=head2 Perl 5.10.1+ (or else 5.8.9+) is Recommended

These versions of perl yield much more detailed information about calls to
BEGIN, CHECK, INIT, and END blocks, the code handling tied or overloaded
variables, and callbacks from XS code.

Perl 5.12 will hopefully also fix an inaccuracy in the timing of the last
statement and the condition clause of some kinds of loops:
L<http://rt.perl.org/rt3/Ticket/Display.html?id=60954>

lib/Devel/NYTProf.pm  view on Meta::CPAN

For example, the L<Readonly> module croaks with "Invalid tie" when profiled with
perl versions before 5.8.8. That's because L<Readonly> explicitly checking for
certain values from caller(). The L<NEXT> module is also affected.

=head2 For perl < 5.10.1 it can't see some implicit calls and callbacks

For perl versions prior to 5.8.9 and 5.10.1, some implicit subroutine calls
can't be seen by the I<subroutine> profiler. Technically this affects calls
made via the various perl C<call_*()> internal APIs.

For example, BEGIN/CHECK/INIT/END blocks, the C<TIE>I<whatever> subroutine
called by C<tie()>, all calls made via operator overloading, and callbacks from
XS code, are not seen.

The effect is that time in those subroutines is accumulated by the
subs that triggered the call to them. So time spent in calls invoked by
perl to handle overloading are accumulated by the subroutines that trigger

 view release on metacpan or  search on metacpan

lib/Devel/Profiler.pm  view on Meta::CPAN

There are no items in this list by default.  Be sure to specify the
fully-qualified name - i.e. "Time::HiRes::time" not just "time".

=item sub_filter

The sub_filter option allows you to specify one or more callbacks to
be used to decide whether to profile a subroutine or not.  The callbacks
will recieve two parameters - the package name and the subroutine
name.

For example, to avoid wrapping all upper-case subroutines:

 view release on metacpan or  search on metacpan

CHANGES  view on Meta::CPAN

0.01 2012-09-29 Tim Bunce

 * Created new Devel::Memory extension using a modified version of
    Devel::Size's perl memory data crawler, extended to support
    callbacks, a 'data path name' concept, data streaming,
    data processing and visualization.

 * The Devel::Memory core was based on 0.77. The generic changes
    will be fed back to Devel::Size so it will remain the
    canonical source of knowledge of how to crawl perl internals.

 view release on metacpan or  search on metacpan

lib/Devel/StatProfiler.pm  view on Meta::CPAN

will report that the code at F<foo.pl> line 10 has spent approximately
the same time in calling C<foo> and C<bar>, and will report C<foo> as
being called from the main program rather than from C<bar>.

=head2 XSUBs with callbacks

Since XSUBs don't have a Perl-level stack frame, Perl code called from
XSUBs is reported as if called from the source line calling the XSUB.

Additionally, the exclusive time for the XSUB incorrectly includes the
time spent in callbacks.

=head2 XSUBs and overload

If an object has an overloaded C<&{}> operator (code dereference)
returning an XSUB as the code reference, the overload might be called

lib/Devel/StatProfiler.pm  view on Meta::CPAN

=head2 changing profiler state

Calling C<enable_profile>, C<disable_profile> and
C<stop_profile> from an inner runloop (including but not limited to
from C<use>, C<require>, C<sort> blocks, callbacks invoked from XS
code) can have confusing results: runloops started afterwards will
honor the new state, outer runloops will not.

Unfortunately there is no way to detect the situaltion at the moment.

 view release on metacpan or  search on metacpan

xt/author/pod_spelling_system.t  view on Meta::CPAN

TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP

 view release on metacpan or  search on metacpan

xt/author/pod_spelling_system.t  view on Meta::CPAN

TODO
filename
filenames
login
callback
callbacks
standalone
VMS
hostname
hostnames
TCP

 view release on metacpan or  search on metacpan

ptkdb.pm  view on Meta::CPAN

Be aware that most perlTk applications have a central event loop.
User actions, such as mouse clicks, key presses, window exposures, etc
will generate 'events' that the script will process. When a perlTk
application is running, its 'MainLoop' call will accept these events
and then dispatch them to appropriate callbacks associated with the
appropriate widgets.

Ptkdb has its own event loop that runs whenever you've stopped at a
breakpoint and entered the debugger. However, it can accept events
that are generated by other perlTk windows and dispatch their
callbacks.  The problem here is that the application is supposed to be
'stopped', and logically the application should not be able to process
events.

A future version of ptkdb will have an extension that will 'filter'
events so that application events are not processed while the debugger

 view release on metacpan or  search on metacpan

tcltkdb.pm  view on Meta::CPAN

Be aware that most perlTk applications have a central event loop.
User actions, such as mouse clicks, key presses, window exposures, etc
will generate 'events' that the script will process. When a perlTk
application is running, its 'MainLoop' call will accept these events
and then dispatch them to appropriate callbacks associated with the
appropriate widgets.

Ptkdb has its own event loop that runs whenever you've stopped at a
breakpoint and entered the debugger. However, it can accept events
that are generated by other perlTk windows and dispatch their
callbacks.  The problem here is that the application is supposed to be
'stopped', and logically the application should not be able to process
events.

=head2 Debugging CGI Scripts

 view release on metacpan or  search on metacpan

tkdb.pm  view on Meta::CPAN

Be aware that most perlTk applications have a central event loop.
User actions, such as mouse clicks, key presses, window exposures, etc
will generate 'events' that the script will process. When a perlTk
application is running, its 'MainLoop' call will accept these events
and then dispatch them to appropriate callbacks associated with the
appropriate widgets.

=head2 Debugging CGI Scripts

One advantage of ptkdb over the builtin debugger(-d) is that it can be

 view release on metacpan or  search on metacpan

lib/Device/Ericsson/AccessoryMenu.pm  view on Meta::CPAN

=head2 control

Respond to what the phone is sending back over the port, invoking
callbacks and all that jazz.

=cut

sub control {
    my $self = shift;

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

Changes
CONTRIBUTING
environment
examples/example-blink.pl
examples/example-callbacks.pl
examples/example-i2c.pl
examples/example-matrix-draw.pl
examples/example-matrix-time.pl
examples/example-matrix-time2.pl
examples/example-matrix.pl

 view release on metacpan or  search on metacpan

lib/Device/GPS.pm  view on Meta::CPAN

    is       => 'ro',
    isa      => 'Device::GPS::Connection',
    required => 1,
);

has '_callbacks' => (
    is  => 'ro',
    isa => 'HashRef[ArrayRef[CodeRef]]',
    default => sub {{
        CALLBACK_POSITION     => [],
        CALLBACK_ACTIVE_SATS  => [],

lib/Device/GPS.pm  view on Meta::CPAN

sub add_callback
{
    my ($self, $type, $callback) = @_;
    push @{ $self->_callbacks->{$type} }, $callback;
    return 1;
}

sub parse_next
{

lib/Device/GPS.pm  view on Meta::CPAN

    my ($type, @data) = split /,/, $sentence;
    my $checksum = pop @data;
    # TODO verify checksum
    @data = $self->_convert_data_by_type( $type, @data );

    foreach my $callback (@{ $self->_callbacks->{$type} }) {
        $callback->(@data);
    }

    return 1;
}

 view release on metacpan or  search on metacpan

lib/Device/PaloAlto/Firewall/Test.pm  view on Meta::CPAN

    my %args = validate(@_, 
        {   
            percent => { 
                type => SCALAR,
                default => 1,
                callbacks => {
                    'valid_percent' => sub{ $_[0] > 0 and $_[0] <= 100; } 
                },
            }
        }   
    );

 view release on metacpan or  search on metacpan

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

=head1 DESCRIPTION

=head2 WHAT CAN THE SDK DO ?

The SDK provided by Saleae Logic registers a bunch of callbacks and then invokes
them with some inputs like data and the device identifiers. Multiple devices can
be handled with the same callback functions. The device SDK creates a separate
thread to manage its callbacks. The SDK supports Logic and Logic16 devices.

We mimic the same functionality where one object created by
C<Device::SaleaeLogic> can handle any number of Saleae Logic devices
simultaneously connected to the computer via USB port. Hence, you will see each
callback having 2 default arguments: the object itself and a device ID.

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

=over 4

=item C<new(%options)>

You should use this function to create a Device::SaleaeLogic object and
setup the callbacks to be invoked by the Device SDK.
The following are the callbacks and other options that you need or may want to setup:

=over 8

=item C<on_connect>

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    $self->begin();

This method should B<not> be invoked from any callback provided to the C<new()>
function. It has to be invoked from outside of the callbacks as shown in
F<share/example.pl> in the distribution.

=item C<DESTROY()>

This method gets automatically called by Perl when destroying the object created

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    my $dev_id = $self->get_device_id($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<is_usb2($id)>

This method informs the user if the Saleae Logic device is connected via a USB

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

        # ... it may determine the speed with which you may be able to sample
        # ... but it is still not very useful
    }

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<is_streaming($id)>

This method informs the user whether the device with ID C<$id> is streaming data

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

        # ... do something ...
        # ... look at the section for read_start() for an example ...
    }

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<get_channel_count($id)>

This method returns the number of channels on the device with ID C<$id>. Most

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    my $chcnt = $self->get_channel_count($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<get_sample_rate($id)>

This method returns the current sampling rate of the device with ID C<$id> in

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    my $rate = $self->get_sample_rate($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<set_sample_rate($id, $rate)>

This method sets the sampling rate to the value C<$rate> in Hz for the device

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    my $rate = 500000;    
    $self->set_sample_rate($id, $rate);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<get_supported_sample_rates($id)>

This method returns an array reference of all the supported sample rates for the

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    my $rates = $self->get_supported_sample_rates($id);
    print "Supported rates in Hz: ", join (", ", @$rates), "\n";

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<is_logic16($id)>

This method returns the value 1 if the device with ID C<$id> is a Logic16

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:
    
    print "I am a Logic16 device\n" if $self->is_logic16($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<is_logic($id)>

This method returns the value 1 if the device with ID C<$id> is a Logic device.

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:
    
    print "I am a Logic device\n" if $self->is_logic($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<get_use5volts($id)>

This method returns 1 or 0, if the Logic16 device with ID C<$id> is running in 5V mode.

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    print "I am in 5V mode\n" if $self->get_use5volts($id);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<set_use5volts($id, $flag)>

This method sets the 5V mode to be either 1 or 0 for the Logic16 device given by

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke this method is as below:

    $self->set_use5volts($id, 1);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<get_active_channels($id)>

This method returns an array reference of the indexes of all the active channels

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    my $channels = $self->get_active_channels($id);
    print "Active Channels: ", join (", ", @$channels), "\n" if $channels;

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<set_active_channels($id, $aref)>

This method takes an array reference C<$aref> with the values being the indexes

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    my $channels = [0, 2, 4, 8, 10, 12, 14 ];
    $self->set_active_channels($id, $channels);

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<read_start($id)>

This method starts the data sampling from the Logic or Logic16 device given by

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    unless ($self->is_streaming($id)) {
        $self->read_start($id);
    }

This method should B<not> be invoked from any callback provided to the C<new()>
function. It has to be invoked from outside of the callbacks as shown in
F<share/example.pl> in the distribution.

=item C<stop($id)>

This method stops the data streaming that is currently happening for the Logic

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

    if ($self->is_streaming($id)) {
        $self->stop($id);
    }

This method can be invoked from any callback provided to the C<new()> function
or from outside the callbacks as long as you have a copy of the
Device::SaleaeLogic object created by C<new()> and a copy of the C<$id> as well.

=item C<write_start($id)>

This method starts the data writing to the Logic device given by

lib/Device/SaleaeLogic.pm  view on Meta::CPAN

The way to invoke it is this:

    $self->write_start($id);

This method should B<not> be invoked from any callback provided to the C<new()>
function. It has to be invoked from outside of the callbacks.

=back

=head2 EXPORT

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

 eg/demo2.plx		- "poor man's" readline and chatV
 eg/demo3.plx		- looks like a setup menu - but only looks :-(
 eg/demo4.plx		- simplest setup: "new", "required param"
 eg/demo5.plx		- "waitfor" and "nextline" using lookfor
 eg/demo6.plx		- basic tied FileHandle operations, record separators
 eg/demo7.plx		- a Perl/Tk based terminal, event loop and callbacks
 eg/demo8.plx		- command line terminal emulator with Term::Readkey
 eq/options.plx		- post-install test that prints available options
 eg/example1.txt	- examples from The Perl Journal #13
 eg/example2.txt	- (minimal mods for cross-platform use)
 eg/example3.txt

README  view on Meta::CPAN

Demo6.plx demonstrates tied FileHandles. Perl 5.005 is recommended.
It "requires" 5.004. It implements timeouts on all user inputs - so
you can run it "hands-off" to see what happens.

Demo7.plx uses Tk to create a terminal emulator. Its included to show
polling and callbacks using an event loop.

Demo8.plx is a simple command-line terminal emulator contributed by
Andrej Mikus.

The Perl Journal #13 included an article on Controlling a Modem with

 view release on metacpan or  search on metacpan

lib/Device/WebIO/Dancer.pm  view on Meta::CPAN

    return send_file( '/etc/hosts',
        streaming    => 1,
        system_path  => 1,
        content_type => $mime_type,
        callbacks    => {
            around_content => sub {
                my ($writer, $chunk) = @_;

                my $buf;
                while( read( $in_fh, $buf, VID_READ_LENGTH ) ) {

 view release on metacpan or  search on metacpan

lib/Device/WebIO/RaspberryPi.pm  view on Meta::CPAN

    is      => 'rw',
    default => sub {[
       8000
    ]},
);
has '_vid_stream_callbacks' => (
    is      => 'rw',
    default => sub {[]},
);
has '_vid_stream_callback_types' => (
    is      => 'rw',

lib/Device/WebIO/RaspberryPi.pm  view on Meta::CPAN

sub vid_stream_callback
{
    my ($self, $pin, $type, $callback) = @_;
    die "Do not support type '$type'" unless exists $ALLOWED_VIDEO_TYPES{$type};
    $self->_vid_stream_callbacks->[$pin] = $callback;
    $self->_vid_stream_callback_types->[$pin] = $type;
    return 1;
}

sub vid_stream_begin_loop

lib/Device/WebIO/RaspberryPi.pm  view on Meta::CPAN

    my ($self, $channel) = @_;
    my $width    = $self->vid_width( $channel );
    my $height   = $self->vid_height( $channel );
    my $fps      = $self->vid_fps( $channel );
    my $bitrate  = $self->vid_kbps( $channel );
    my $callback = $self->_vid_stream_callbacks->[$channel];
    my $type     = $self->_vid_stream_callback_types->[$channel];
    my $use_audio = $self->vid_use_audio;
    my $audio_dev = $self->vid_audio_input_device;

 view release on metacpan or  search on metacpan

lib/Device/WebIO.pm  view on Meta::CPAN

=head3 digital_input_begin_loop

  digital_input_begin_loop( $name );

Start the loop that will trigger callbacks.

=head2 Input AnyEvent

These can be used if the device does the C<DigitalInputAnyEvent> role.

lib/Device/WebIO.pm  view on Meta::CPAN

=head3 vid_stream_begin_loop

  vid_stream_begin_loop( $name, $channel );

Start the loop that will trigger callbacks.

=head2 Still Image

=head3 img_channels

 view release on metacpan or  search on metacpan

share/htdocs/d3.layout.cloud.js  view on Meta::CPAN

      while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t;
      return;
    }

    // If a type was specified, set the callback for the given type and name.
    // Otherwise, if a null callback was specified, remove callbacks of the given name.
    if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback);
    while (++i < n) {
      if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback);
      else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null);
    }

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	- silenced MSC compiler warning about signed/unsigned comparison
		-- ref. SHA.xs (rt.cpan.org #95830)

5.91  Fri May 16 10:21:44 MST 2014
	- restored original 'addfile' for use on opened file handles
		-- allows callbacks in place of actual files
			-- ref. IO::Callback (rt.cpan.org #95643)
	- re-established inheritance from Digest::base
		-- to pick up future Digest enhancements automatically
	- cleaned up documentation

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

		-- use 'classname' instead of 'class'
			-- ref. SHA3.xs (rt.cpan.org #96090)

0.21  Fri May 16 10:21:46 MST 2014
	- restored original 'addfile' for use on opened file handles
		-- allows callbacks in place of actual files
			-- ref. IO::Callback (rt.cpan.org #95643)
	- re-established inheritance from Digest::base
		-- to pick up future Digest enhancements automatically
	- cleaned up documentation