view release on metacpan or search on metacpan
lib/Authen/Simple/DBM.pm view on Meta::CPAN
},
type => {
type => Params::Validate::SCALAR,
default => 'SDBM',
optional => 1,
callbacks => {
'is either DB, GDBM, NDBM or SDBM' => sub {
$_[0] =~ qr/^CDB|DB|GDBM|NDBM|SDBM$/;
}
}
}
view release on metacpan or search on metacpan
lib/Authen/Simple/POP3.pm view on Meta::CPAN
},
method => {
type => Params::Validate::SCALAR,
default => 'plain',
optional => 1,
callbacks => {
'valid option' => sub {
$_[0] =~ /^apop|plain|sasl$/;
}
}
}
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
examples/demoserver/u2f-api.js view on Meta::CPAN
* @private
*/
u2f.reqCounter_ = 0;
/**
* A map from requestIds to client callbacks
* @type {Object.<number,(function((u2f.Error|u2f.RegisterResponse))
* |function((u2f.Error|u2f.SignResponse)))>}
* @private
*/
u2f.callbackMap_ = {};
examples/demoserver/u2f-api.js view on Meta::CPAN
u2f.getMessagePort(function(port) {
u2f.port_ = port;
u2f.port_.addEventListener('message',
/** @type {function(Event)} */ (u2f.responseHandler_));
// Careful, here be async callbacks. Maybe.
while (u2f.waitingForPort_.length)
u2f.waitingForPort_.shift()(u2f.port_);
});
}
u2f.waitingForPort_.push(callback);
view release on metacpan or search on metacpan
- Aw::Event::getFIELD returns a hash with "value" and "type" keys.
- added BEGIN blocks throughout.
0.10b Tue Mar 14 12:40:07 EST 2000
- some memory leaks for variables in callbacks pushed onto Perl's stack.
- The Aw::Log data type now includes maxMessagesize which has a default
value of 2048. Methods getMessageSize and setMessageSize are provided
to manipulate this value.
- "strict" added to all .pm files.
- Makefile.PL is smart enough to know where default libraries and include
view release on metacpan or search on metacpan
PerForm tends to make life easier for you if your form data is coming from
different data sources, such as DBI, or even XML.
PerForm works as an XSP taglib, meaning you simply add some custom XML tags
to your XSP page, and PerForm does the rest. Well, almost... PerForm works
mainly by callbacks, as you will see below.
=head1 EXAMPLE FORM
Ignoring the outside XSP and namespace declarations, assuming the prefix "f"
is bound to the PerForm namespace:
<f:submit name="save" value="Save" goto="users.xsp" />
<f:cancel name="cancel" value="Cancel" goto="home.html" />
</f:form>
Now it is important to bear in mind that this is just the form, and alone it
is fairly useless. You also need to add callbacks. You'll notice with each
of these callbacks you recieve a C<$ctxt> object. This is simply an empty
hash-ref that you can use in the callbacks to maintain state. Actually
"empty" is an exhageration - it contains two entries always: C<Form> and
C<Apache>. "Form" is a simply a hashref of the entries in the form (actually
it is an Apache::Table object, which allows for supporting multi-valued
parameters). So for example, the firstname below is in
C<$ctxt->{Form}{firstname}>. "Apache" is the C<$r> apache request object for
I<goto> attribute on the submit or cancel button, or implement a callback
and return a URI to redirect to.
=head1 THE CONTEXT OBJECT
Each of the form callbacks is passed a context object. This is a hashref you
are allowed to use to maintain state between your callbacks. There is a new
context object created for every form on your XSP page. There are two
entries filled in automatically into the hashref for you:
=over 4
=head1 ARRAYED FORM ELEMENTS
Sometimes you need to display a list of items in your form where the number
of items is not known until runtime. Use arrayed form elements to trigger
the same callback for each item in the list. When setting up each element,
use an index to identify each member of the list. The callbacks will be
passed the index as a parameter. e.g.
Your form may have a section like this:
<xsp:logic>
be in the class you inherit from, reducing code duplication, memory usage,
and complexity.
=head1 SPECIFYING CALLBACKS
All of the documentation here uses the default callbacks which are implied
by the name of the form element you give. Unfortunately this makes it
difficult to have multiple elements with the same validation logic without
duplicating code. In order to get around this you can manually specify the
callbacks to use.
Every main tag supports both C<onvalidate> and C<onload> attributes which
specify perl function names to validate and load respectively. Submit
buttons support C<onsubmit> attributes. Cancel buttons support C<oncancel>
attributes. Forms themselves support both C<oncancel> and C<onsubmit>
attributes.
If a form is submitted without pressing a button (such as via JavaScript,
or by hitting <Enter>, then the form tag's C<onsubmit> callback will be
used. It is always sensible to define this to be one of your button's
submit callbacks.
All tags allow a C<disabled> attribute. Set this to a true value (i.e.
C<disabled="1">) to set the control to disabled. This will be interpreted
as a HTML 4.0 feature in the default perform stylesheet.
=over 4
=item name (mandatory)
The name of the submit button. Used for the submit callbacks.
=item value
The text on the button, if you are using a browser generated button.
=over 4
=item name (mandatory)
The name of the textfield. Should be unique to the entire XSP page, as
callbacks only use the widget name. Can also be used in
C<$ctxt-E<gt>{Form}{E<lt>nameE<gt>}> to retrieve the value.
=item default
A default value for the textfield.
=head2 <f:single-select/>
A drop-down select list of items.
The single-select and multi-select (below) elements can be populated either
by callbacks or through embedded elements.
B<Attributes:>
=over 4
view release on metacpan or search on metacpan
perloptree.pod view on Meta::CPAN
=head2 Modules
The most important op tree module is L<B::Concise> by Stephen McCamant.
L<B::Utils> provides abstract-enough op tree grep's and walkers with
callbacks from the perl level.
L<Devel::Hook> allows adding perl hooks into the BEGIN, CHECK,
UNITCHECK, INIT blocks.
L<Devel::TypeCheck> tries to verify possible static typing for
view release on metacpan or search on metacpan
lib/B/CompilerPhase/Hook.pm view on Meta::CPAN
# With apologies to the `BEGIN-UNITCHECK-CHECK-INIT-and-END` section of `perlmod`
=head1 DESCRIPTION
This module makes it possible to enqueue callbacks to be run during
the various Perl compiler phases, with the aim of doing multi-phase
meta programming in a reasonably clean way.
=head1 FUNCTIONS
lib/B/CompilerPhase/Hook.pm view on Meta::CPAN
=over 4
=item L<Devel::Hook>
This module provides C<push> and C<unshift> access to the internal
arrays that hold the set of compiler phase callbacks. It relies on
you to do the right thing when choosing which of the two actions
(C<push> or C<unshift>) to take.
=back
view release on metacpan or search on metacpan
lib/B/Hooks/AtRuntime.pm view on Meta::CPAN
my ($new) = @_;
# By deleting the stash entry we ensure the only ref to the glob is
# through the optree it was compiled into. This means that if that
# optree is ever freed, the glob will disappear along with anything
# closed over by the user's callbacks.
delete $B::Hooks::AtRuntime::{hooks};
no strict "refs";
$new and *{"hooks"} = $new;
}
lib/B/Hooks/AtRuntime.pm view on Meta::CPAN
my $depth = count_BEGINs()
or croak "You must call at_runtime at compile time";
my $hk;
unless ($hk = $Hooks[$depth]) {
# Close over an array of callbacks so we don't need to keep
# stuffing text into the buffer.
my @hooks;
$hk = $Hooks[$depth] = \@hooks;
replace_hooks $hk;
view release on metacpan or search on metacpan
lib/B/Hooks/EndOfScope/PP/FieldHash.pm view on Meta::CPAN
# * %^H is deallocated on scope exit, so any references to it disappear
# * A lost weakref in a fieldhash causes the corresponding key to be deleted
# * Deletion of a key on a tied hash triggers DELETE
#
# Therefore the DELETE of a tied fieldhash containing a %^H reference will
# be the hook to fire all our callbacks.
fieldhash my %hh;
{
package # hide from pause too
B::Hooks::EndOfScope::PP::_TieHintHashFieldHash;
view release on metacpan or search on metacpan
lib/B/Hooks/OP/Check/EntersubForCV.pm view on Meta::CPAN
__END__
=head1 NAME
B::Hooks::OP::Check::EntersubForCV - Invoke callbacks on construction of entersub OPs for certain CVs
=head1 SYNOPSIS
=head2 From Perl
view release on metacpan or search on metacpan
# B::Hooks::OP::Check::LeaveEval
Setup callbacks to call when new code is compiled
## Author
Szymon Nieznański <s.nez@member.fsf.org>
view release on metacpan or search on metacpan
lib/B/Hooks/OP/Check/StashChange.pm view on Meta::CPAN
__END__
=head1 NAME
B::Hooks::OP::Check::StashChange - Invoke callbacks when the stash code is being compiled in changes
=head1 SYNOPSIS
=head2 From Perl
lib/B/Hooks/OP/Check/StashChange.pm view on Meta::CPAN
=head2 TYPES
=head3 OP *(*hook_op_check_stashchange_cb) (pTHX_ OP *op, const char *new_stash, const char *old_stash, void *user_data)
The type the callbacks need to implement.
=head2 FUNCTIONS
=head3 UV hook_op_check_stashchange (hook_op_check_stashchange_cb cb, void *user_data)
view release on metacpan or search on metacpan
lib/B/Hooks/OP/Check.pm view on Meta::CPAN
use strict;
use warnings;
package B::Hooks::OP::Check; # git description: 0.21-5-g968d5ca
# ABSTRACT: Wrap OP check callbacks
require 5.008001;
use parent qw/DynaLoader/;
our $VERSION = '0.22';
lib/B/Hooks/OP/Check.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
B::Hooks::OP::Check - Wrap OP check callbacks
=head1 VERSION
version 0.22
lib/B/Hooks/OP/Check.pm view on Meta::CPAN
CODE:
hook_op_check_remove (OP_CONST, my_hook_id);
=head1 DESCRIPTION
This module provides a C API for XS modules to hook into the callbacks of
C<PL_check>.
L<ExtUtils::Depends> is used to export all functions for other XS modules to
use. Include the following in your Makefile.PL:
lib/B/Hooks/OP/Check.pm view on Meta::CPAN
=head1 TYPES
=head2 typedef OP *(*hook_op_check_cb) (pTHX_ OP *, void *);
Type that callbacks need to implement.
=head2 typedef UV hook_op_check_id
Type to identify a callback.
view release on metacpan or search on metacpan
lib/B/Hooks/OP/PPAddr.pm view on Meta::CPAN
=head2 OP
typedef OP *(*hook_op_ppaddr_cb_t) (pTHX_ OP *, void *user_data)
Type that callbacks need to implement.
=head1 FUNCTIONS
=head2 hook_op_ppaddr
lib/B/Hooks/OP/PPAddr.pm view on Meta::CPAN
=head2 hook_op_ppaddr_around
void hook_op_ppaddr_around (OP *op, hook_op_ppaddr_cb_t before, hook_op_ppaddr_cb_t after, void *user_data)
Register the callbacks C<before> and C<after> to be called before and after the
execution of C<op>. C<user_data> will be passed to the callback as the last
argument.
=head1 SEE ALSO
view release on metacpan or search on metacpan
lib/B/OPCheck.pm view on Meta::CPAN
package B::OPCheck; # git description: v0.31-4-gd081d88
# ABSTRACT: PL_check hacks using Perl callbacks
use 5.008;
use strict;
use warnings;
lib/B/OPCheck.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
B::OPCheck - PL_check hacks using Perl callbacks
=head1 VERSION
version 0.32
view release on metacpan or search on metacpan
=item result
The request results are processed synchronously by C<poll_cb>.
The C<poll_cb> function will process all outstanding aio requests by
calling their callbacks, freeing memory associated with them and managing
any groups they are contained in.
=item done
Request has reached the end of its lifetime and holds no resources anymore
C<BDB::poll_cb> to process requests (more correctly the mininum amount
of time C<poll_cb> is allowed to use).
Setting C<max_poll_time> to a non-zero value creates an overhead of one
syscall per request processed, which is not normally a problem unless your
callbacks are really really fast or your OS is really really slow (I am
not mentioning Solaris here). Using C<max_poll_reqs> incurs no overhead.
Setting these is useful if you want to ensure some level of
interactiveness when perl is not fast enough to process all requests in
time.
view release on metacpan or search on metacpan
lib/BIND/Conf_Parser.pm view on Meta::CPAN
$self->{_file} = @_ ? shift : "a scalar";
$self->{_line} = 0;
$self->parse_conf;
}
# The callbacks
sub handle_logging_category {}; # $name, \@names
sub handle_logging_channel {}; # $name, \%options
sub handle_key {}; # $name, $algo, $secret
sub handle_acl {}; # $name, $addrmatchlist
sub handle_option {}; # $option, $argument
lib/BIND/Conf_Parser.pm view on Meta::CPAN
The parse() method cannot be called multiple times with parts of
statements.
Comments are not passed to a callback method.
Some callbacks are invoked before the semicolon that terminates the
corresponding syntactic form is actually recognized. It is therefore
possible for a syntax error to not be detected until after a callback
is invoked for the presumably completly parsed form. No attempt is
made to delay the invocation of callbacks to the completion of toplevel
statements.
=head1 NOTE
This version of C<BIND::Conf_Parser> corresponds to BIND version 8.2.2
view release on metacpan or search on metacpan
lib/BPM/Engine/ProcessRunner.pm view on Meta::CPAN
I<complete> or I<execute>.
=item * C<$node>
The first argument passed to the C<cb_*> callback method, the respective entity
node in the process that this callback is emitted for. On activity callbacks,
this is the activity object, the task object on task callbacks, the process
object for process entities, and transition for transition calls.
=item * C<$instance>
The second argument passed to the C<cb_*> callback method, being the instance
view release on metacpan or search on metacpan
bson/bson-types.h view on Meta::CPAN
const char *key,
void *data);
/* corrupt BSON, or unsupported type and visit_unsupported_type not set */
void (*visit_corrupt) (const bson_iter_t *iter,
void *data);
/* normal bson field callbacks */
bool (*visit_double) (const bson_iter_t *iter,
const char *key,
double v_double,
void *data);
bool (*visit_utf8) (const bson_iter_t *iter,
view release on metacpan or search on metacpan
lib/Backbone/Events.pm view on Meta::CPAN
Remove a previously-bound callback from an object.
=head2 trigger($event, @args)
Trigger callbacks for the given event.
=head2 once($event, $callback)
Just like 'on', but causes the bound callback to fire only once before being
removed.
view release on metacpan or search on metacpan
}
*path = '\0';
}
/*
* Simple logging functions. If you register callbacks, they will be called.
* Otherwise, messages are accumulated, and a callback allows the
* log strings to be fetched.
*
* We store the data in a single buffer of '\0'-terminated strings.
*/
view release on metacpan or search on metacpan
t/filesystem/visitor.t view on Meta::CPAN
'got all default files' );
#-----------------------------------------------------------------------
# visitor callbacks
#-----------------------------------------------------------------------
my $n = 0;
@files = $vdir->visit(
accept_file => sub { $n++ }
view release on metacpan or search on metacpan
share/public/js/base/jquery.form.js view on Meta::CPAN
}
else {
options.data = q; // data is the query string for 'post'
}
var $form = this, callbacks = [];
if (options.resetForm) {
callbacks.push(function() { $form.resetForm(); });
}
if (options.clearForm) {
callbacks.push(function() { $form.clearForm(); });
}
// perform a load on the target only if dataType is not provided
if (!options.dataType && options.target) {
var oldSuccess = options.success || function(){};
callbacks.push(function(data) {
var fn = options.replaceTarget ? 'replaceWith' : 'html';
$(options.target)[fn](data).each(oldSuccess, arguments);
});
}
else if (options.success) {
callbacks.push(options.success);
}
options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg
var context = options.context || options; // jQuery 1.4+ supports scope context
for (var i=0, max=callbacks.length; i < max; i++) {
callbacks[i].apply(context, [data, status, xhr || $form, $form]);
}
};
// are there files to upload?
var fileInputs = $('input:file', this).length > 0;
share/public/js/base/jquery.form.js view on Meta::CPAN
if (xhr.aborted) {
log('upload aborted');
ok = false;
}
// ordering of these callbacks/triggers is odd, but that's how $.ajax does it
if (ok) {
s.success.call(s.context, data, 'success', xhr);
g && $.event.trigger("ajaxSuccess", [xhr, s]);
}
view release on metacpan or search on metacpan
lib/Beam/Emitter.pm view on Meta::CPAN
#pod
#pod This role is used by classes that want to add callback hooks to allow
#pod users to add new behaviors to their objects. These hooks are called
#pod "events". A subscriber registers a callback for an event using the
#pod L</subscribe> or L</on> methods. Then, the class can call those
#pod callbacks by L<emitting an event with the emit() method|/emit>.
#pod
#pod Using the L<Beam::Event> class, subscribers can stop an event from being
#pod processed, or prevent the default action from happening.
#pod
#pod =head2 Using Beam::Event
lib/Beam/Emitter.pm view on Meta::CPAN
$args{ name } ||= $name;
my $event = $class->new( %args );
return $event unless exists $self->_listeners->{$name};
# don't use $self->_listeners->{$name} directly, as callbacks may unsubscribe
# from $name, changing the array, and confusing the for loop
my @listeners = @{ $self->_listeners->{$name} };
for my $listener ( @listeners ) {
$listener->callback->( $event );
lib/Beam/Emitter.pm view on Meta::CPAN
sub emit_args {
my ( $self, $name, @args ) = @_;
return unless exists $self->_listeners->{$name};
# don't use $self->_listeners->{$name} directly, as callbacks may unsubscribe
# from $name, changing the array, and confusing the for loop
my @listeners = @{ $self->_listeners->{$name} };
for my $listener ( @listeners ) {
$listener->callback->( @args );
lib/Beam/Emitter.pm view on Meta::CPAN
This role is used by classes that want to add callback hooks to allow
users to add new behaviors to their objects. These hooks are called
"events". A subscriber registers a callback for an event using the
L</subscribe> or L</on> methods. Then, the class can call those
callbacks by L<emitting an event with the emit() method|/emit>.
Using the L<Beam::Event> class, subscribers can stop an event from being
processed, or prevent the default action from happening.
=head2 Using Beam::Event
view release on metacpan or search on metacpan
lib/Beekeeper/AnyEvent.pm view on Meta::CPAN
USE_PERL_BACKEND: {
# Prefer AnyEvent perl backend over default EV, as it is fast enough
# and it does not ignore exceptions thrown from within callbacks
$ENV{'PERL_ANYEVENT_MODEL'} ||= 'Perl' unless $AnyEvent::MODEL;
}
UNTAINT_IP_ADDR: {
lib/Beekeeper/AnyEvent.pm view on Meta::CPAN
=over
=item *
Prefer the pure perl backend over default EV, as it is fast enough and
it does not ignore exceptions thrown from within callbacks.
=item *
Addresses resolved by AnyEvent::DNS are tainted, causing an "Insecure
dependency in connect" error as Beekeeper runs with taint mode enabled.
view release on metacpan or search on metacpan
lib/Benchmark/Featureset/ParamCheck/Implementation/PV.pm view on Meta::CPAN
use constant short_name => 'PV';
sub get_named_check {
state $check = {
integer => { type => SCALAR, regex => qr/\A-?[0-9]+\z/ },
hashes => { type => ARRAYREF, callbacks => { hashes => sub { !grep ref ne 'HASH', @{$_[0]} } } },
object => { type => OBJECT, can => [qw/print close/] },
};
}
sub get_positional_check {
state $check = [
{ type => SCALAR, regex => qr/\A-?[0-9]+\z/ },
{ type => ARRAYREF, callbacks => { hashes => sub { !grep ref ne 'HASH', @{$_[0]} } } },
{ type => OBJECT, can => [qw/print close/] },
];
}
1;
view release on metacpan or search on metacpan
share/PerlCritic/Critic/Policy/Modules/ProhibitExcessMainComplexity.pm view on Meta::CPAN
complexity of all the code that is B<outside> of any subroutine
declaration.
The usual prescription for reducing complexity is to refactor code
into smaller subroutines. Mark Dominus book "Higher Order Perl" also
describes callbacks, recursion, memoization, iterators, and other
techniques that help create simple and extensible Perl code.
=head1 CONFIGURATION
view release on metacpan or search on metacpan
BerkeleyDB.xs view on Meta::CPAN
softCrash("associate_foreign needs Berkeley DB 4.8 or later") ;
#else
saveCurrentDB(db) ;
if (callback != &PL_sv_undef)
{
//softCrash("associate_foreign does not support callbacks yet") ;
secondary->associated_foreign = newSVsv(callback) ;
callback_ptr = ( secondary->recno_or_queue
? associate_foreign_cb_recno
: associate_foreign_cb);
}
view release on metacpan or search on metacpan
lib/Biblio/COUNTER.pm view on Meta::CPAN
die "Instantiating a report from an array not yet implemented";
}
elsif (ref($how)) {
# Read report from a filehandle
my $fh = $how;
my $callbacks = delete($args{'callback'}) || {};
my $report = Biblio::COUNTER::Report->new(
%args,
'fh' => $fh,
'callback' => {
'output' => sub {
my ($self, $output) = @_;
print $output, "\n";
},
%$callbacks,
},
'rows' => [],
'errors' => 0,
'warnings' => 0,
# Current position within the report
lib/Biblio/COUNTER.pm view on Meta::CPAN
specified that is triggered each time the event occurs; see the B<report>
method for how to specify a callback.
Callbacks must be coderefs, not function or method names.
For example, the following callbacks may be used to provide an indication of
the progress in processing it:
$record_number = 0;
%callbacks = (
'begin_report' => sub {
print STDERR "Beginning report: ";
},
'end_header' => sub {
my ($report, $header) = @_;