synchro results from the CPAN

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

Authen-Simple

1 match

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

Autodia

1 match

CHANGES view on Meta::CPAN

- fixed autodia.pl to allow -i and -d at the same time
- skipcvs option now also skips RCS dirs
- fix to C++ handler to cope with comments like /* .. */ on single line
- fixes to Torque handler
- added umbrello input handler (experimental)
- synchronised autodia_java.pl with autodia.pl

version 1.11 23/12/2003
- added experimental support for Class::Tangram

version 1.10 22/12/2003

view all matches for this distribution

Avro

2 results

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

Aw

2 results

doc/Admin/Aw_Admin_Client.html view on Meta::CPAN

<tr align="center"><th align="left"><a name="getEventAdminTypeDefsByScope"></a>getEventAdminTypeDefsByScope</th><td>( scope_name )</td><td>@ of Aw::Admin::TypeDef</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getEventTypeStats"></a>getEventTypeStats</th><td>( event_type_name )</td><td>Aw::Event</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getLocalTerritoryGateways"></a>getLocalTerritoryGateways</th><td>( )</td><td>@ of % of {gateway_host_name,<br>gateway_broker_name,<br>remote_territory_name,<br>remote_host_name,<br>remote_broker_name,<br>r...
<tr align="center"><th align="left"><a name="getTerritoryACL"></a>getTerritoryACL</th><td>( )</td><td>Aw::Admin::AccessControlList</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getTerritoryGatewayACL"></a>getTerritoryGatewayACL</th><td>( )</td><td>Aw::Admin::AccessControlList</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getTerritoryGatewaySharedEventTypes"></a>getTerritoryGatewaySharedEventTypes</th><td>( territory_name )</td><td>@ of % {event_type_name,<br>accept_publish,<br>accept_subscribe,<br>is_synchronized,<br>subsc...
<tr align="center"><th align="left"><a name="getTerritoryGatewayStats"></a>getTerritoryGatewayStats</th><td>( territory_name )</td><td>Aw::Event</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getTerritoryInfo"></a>getTerritoryInfo</th><td>( )</td><td>% of {territory_name,<br>auth_type,<br>encrypt_level}</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="getTerritoryStats"></a>getTerritoryStats</th><td>( )</td><td>Aw::Event</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="joinTerritory"></a>joinTerritory</th><td>( broker_host, broker_name )</td><td>% of {client_group_names,<br>num_client_group_names,<br>num_efent_type_names}</td><td>YES</td></tr>
<tr align="center"><th align="left"><a name="leaveTerritory"></a>leaveTerritory</th><td>( msecs, forced )</td><td>Boolean</td><td>YES</td></tr>

view all matches for this distribution

AxKit-XSP-Currency

1 match

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

view all matches for this distribution

AxKit-XSP-L10N

1 match

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

view all matches for this distribution

AxKit-XSP-Minisession

1 match

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

view all matches for this distribution

AxKit2

3 results

lib/AxKit2/Plugin.pm view on Meta::CPAN


  sub hook_logging {

If your plugin needs to hook into the same hook more than once, you will need
to write a C<register()> method as shown above. This is usually the case if you
need continuations for some reason (such as doing asynchronous I/O).

All hooks are called as a method on an instance of the plugin object. Params
below are listed without the C<$plugin> or C<$self> object as the first param.

For some plugins returning C<CONTINUATION> is valid. For details on how

lib/AxKit2/Plugin.pm view on Meta::CPAN

read is performed as soon as possible before the API call returns. This may take
very little CPU time because the OS has to wait until the disk head is in the
correct position to perform the actions requested. But it does take "clock" time
which can be put to better use responding to other requests.

In asynchronous I/O the action is requested and a callback is provided to
be called when the action has occured. This allows the event loop to continue
processing other requests while we are waiting for the disk.

This is better explained with a simple example. For this example we'll take the
C<stat()> system call in an attempt to find out if the filename we are

view all matches for this distribution

B-C

1 match

ramblings/remark.js view on Meta::CPAN

require=function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t)...
this.QUOTE_STRING_MODE={className:"string",begin:'"',end:'"',illegal:"\\n",contains:[this.BACKSLASH_ESCAPE]};this.PHRASAL_WORDS_MODE={begin:/\b(a|an|the|are|I|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such)...
SUBST.contains=EXPRESSIONS;return{aliases:["coffee","cson","iced"],keywords:KEYWORDS,contains:EXPRESSIONS.concat([{className:"comment",begin:"###",end:"###"},hljs.HASH_COMMENT_MODE,{className:"function",begin:"("+JS_IDENT_RE+"\\s*=\\s*)?(\\(.*\\))?\\...
}()},{}],8:[function(require,module,exports){exports.addClass=function(element,className){element.className=exports.getClasses(element).concat([className]).join(" ")};exports.removeClass=function(element,className){element.className=exports.getClasse...
events.on("slideChanged",updateHash);navigateByHash()}function navigateByHash(){var slideNoOrName=(dom.getLocationHash()||"").substr(1);events.emit("gotoSlide",slideNoOrName)}function updateHash(slideNoOrName){dom.setLocationHash("#"+slideNoOrName)}}...

view all matches for this distribution

B-DeparseTree

1 match

lib/B/DeparseTree/TreeMain.pm view on Meta::CPAN

	push @ret,
	     join("\n" . (" " x $indent), "BEGIN {", @decls) . "\n}\n";
    return @ret;
}

# generate any pragmas, 'package foo' etc needed to synchronise
# with the given cop

sub pragmata {
    my $self = shift;
    my($op) = @_;

view all matches for this distribution

B-Foreach-Iterator

1 match

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

B-Hooks-OP-Check-EntersubForCV

1 match

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

B-Hooks-OP-Check-StashChange

1 match

use 5.005;
use strict 'vars';

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

B-Hooks-XSUB-CallAsOp

1 match

use 5.005;
use strict 'vars';

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

BDB

3 results

=head1 NAME

BDB - Asynchronous Berkeley DB access

=head1 SYNOPSIS

 use BDB;

See the BerkeleyDB documentation (L<http://www.oracle.com/technology/documentation/berkeley-db/db/index.html>).
The BDB API is very similar to the C API (the translation has been very faithful).

See also the example sections in the document below and possibly the eg/
subdirectory of the BDB distribution. Last not least see the IO::AIO
documentation, as that module uses almost the same asynchronous request
model as this module.

I know this is woefully inadequate documentation. Send a patch!


=item pending

The request has been executed and is waiting for result processing.

While request submission and execution is fully asynchronous, result
processing is not and relies on the perl interpreter calling C<poll_cb>
(or another function with the same effect).

=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.

=head1 BERKELEYDB FUNCTIONS

All of these are functions. The create functions simply return a new
object and never block. All the remaining functions take an optional
callback as last argument. If it is missing, then the function will be
executed synchronously. In both cases, C<$!> will reflect the return value
of the function.

BDB functions that cannot block (mostly functions that manipulate
settings) are method calls on the relevant objects, so the rule of thumb
is: if it's a method, it's not blocking, if it's a function, it takes a

The C<SV *callback> is the optional callback function to call when the
request is completed. This last callback argument is special: the callback
is simply the last argument passed. If there are "optional" arguments
before the callback they can be left out. The callback itself can be left
out or specified as C<undef>, in which case the function will be executed
synchronously.

For example, C<db_env_txn_checkpoint> usually is called with all integer
arguments zero. These can be left out, so all of these specify a call
to C<< DB_ENV->txn_checkpoint >>, to be executed asynchronously with a
callback to be called:

   db_env_txn_checkpoint $db_env, 0, 0, 0, sub { };
   db_env_txn_checkpoint $db_env, 0, 0, sub { };
   db_env_txn_checkpoint $db_env, sub { };

While these all specify a call to C<< DB_ENV->txn_checkpoint >> to be
executed synchronously:

   db_env_txn_checkpoint $db_env, 0, 0, 0, undef;
   db_env_txn_checkpoint $db_env, 0, 0, 0;
   db_env_txn_checkpoint $db_env, 0;

=item BDB::poll_wait

If there are any outstanding requests and none of them in the result
phase, wait till the result filehandle becomes ready for reading (simply
does a C<select> on the filehandle. This is useful if you want to
synchronously wait for some requests to finish).

See C<nreqs> for an example.

=item BDB::poll

=over 4

=item BDB::min_parallel $nthreads

Set the minimum number of BDB threads to C<$nthreads>. The current
default is C<8>, which means eight asynchronous operations can execute
concurrently at any one time (the number of outstanding requests,
however, is unlimited).

BDB starts threads only on demand, when an BDB request is queued and
no free thread exists. Please note that queueing up a hundred requests can

      )
   }

It works by polling for results till the request has finished and then
sets C<$!> to the return value. This means that if you don't use a
callback, BDB would simply fall back to synchronous operations.

By default, or if the sync prepare function is set to C<undef>, is to
execute callback-less BDB requests in the foreground thread, setting C<$!>
to the return value, without polling for other events.

view all matches for this distribution

BPAN

1 match

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

view all matches for this distribution

BPM-Engine

14 results

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

BPM-XPDL

5 results

lib/BPM/XPDL/xsd/xpdl-2.0/TC-1025_schema_20_2005-09-07_xpdl.xsd view on Meta::CPAN

					<xsd:documentation>BPMN: needed for independent subprocess</xsd:documentation>
				</xsd:annotation>
			</xsd:attribute>
			<xsd:attribute name="InstanceDataField" type="xsd:string" use="optional">
				<xsd:annotation>
					<xsd:documentation> Used to store the instance id of the subflow instantiated by the activity. This is then available later on (e.g. for correlation, messaging etc.) especially in the case of asynchronous invocation.</xsd:documentation>
				</xsd:annotation>
			</xsd:attribute>
			<xsd:attribute name="StartActivitySetId" type="xsd:NMTOKEN" use="optional"/>
			<xsd:attribute name="StartActivityId" type="xsd:NMTOKEN" use="optional"/>
			<xsd:anyAttribute namespace="##other" processContents="lax"/>

view all matches for this distribution

BSD-Process-Affinity

1 match

use 5.005;
use strict 'vars';

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

BSD-devstat

1 match

use 5.005;
use strict 'vars';

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

BSON-XS

3 results

bson/bson-atomic.h view on Meta::CPAN


#if defined(_WIN32)
# define bson_memory_barrier() MemoryBarrier()
#elif defined(__GNUC__)
# if BSON_GNUC_CHECK_VERSION(4, 1)
#  define bson_memory_barrier() __sync_synchronize()
# else
#  warning "GCC Pre-4.1 discovered, using inline assembly for memory barrier."
#  define bson_memory_barrier() __asm__ volatile ("":::"memory")
# endif
#elif defined(__SUNPRO_C)

view all matches for this distribution

BZ-Client

1 match

lib/BZ/Client/Bugzilla.pm view on Meta::CPAN


=item db_time

I<db_time> (L<DateTime>) -  The current time in UTC, according to the Bugzilla database server.

Note that Bugzilla assumes that the database and the webserver are running in the same time zone. However, if the web server and the database server aren't synchronized for some reason, this is the time that you should rely on for doing searches and ...

=item web_time

I<web_time> (L<DateTime>) -  This is the current time in UTC, according to Bugzilla's web server.

view all matches for this distribution

Backblaze-B2

5 results

lib/Backblaze/B2.pm view on Meta::CPAN

        api => 'Backblaze::B2::v1::Synchronous', # the default
    );

Creates a new instance. Depending on whether you pass in
C<<Backblaze::B2::v1::Synchronous>> or C<<Backblaze::B2::v1::AnyEvent>>,
you will get a synchronous or asynchronous API.

The synchronous API is what is documented here, as this is the
most likely use case.

    my @buckets = $b2->buckets();
    for( @buckets ) {
        ...
    }

The asynchronous API is identical to the synchronous API in spirit, but
will return L<Promises> . These condvars usually return
two or more parameters upon completion:

    my $results = $b2->buckets();
    $results->then( sub{

lib/Backblaze/B2.pm view on Meta::CPAN

        for( @buckets ) {
            ...
        }
    }

The asynchronous API puts the burden of error handling into your code.

=cut

use vars '$API_BASE';
$API_BASE = 'https://api.backblazeb2.com/b2api/v1/';

sub new {
    my( $class, %options ) = @_;
    
    # Hrr. We need to get at an asynchronous API here and potentially
    # wrap the results to synchronous results in case the user wants them.
    # Turtles all the way down, this means we can't reuse calls into ourselves...

    $options{ api } ||= 'Backblaze::B2::v1::Synchronous';
    if( ! ref $options{ api }) {
        eval "require $options{ api }";

lib/Backblaze/B2.pm view on Meta::CPAN

sub new {
    my( $class, %options ) = @_;
    weaken $options{ parent };
    
    # Whoa! We assume that the async version has the same class name
    # as the synchronous version and just strip it off.
    $options{ file_class } =~ s!::Synchronized$!!;
    
    bless \%options => $class,
}

view all matches for this distribution

Backup-Duplicity-YADW

4 results

lib/Backup/Duplicity/YADW.pm view on Meta::CPAN

	args_pos
		my $self,
		my $cmds;

	if ( $self->_conf()->get('asyncupload') ) {
		push @$cmds, '--asynchronous-upload';
	}
}

sub _get_incl_excl_list {

view all matches for this distribution

BackupPC-XS

1 match

zlib/inflate.h view on Meta::CPAN

    CHECK,      /* i: waiting for 32-bit check value */
    LENGTH,     /* i: waiting for 32-bit length (gzip) */
    DONE,       /* finished check, done -- remain here until reset */
    BAD,        /* got a data error -- remain here until reset */
    MEM,        /* got an inflate() memory error -- remain here until reset */
    SYNC        /* looking for synchronization bytes to restart inflate() */
} inflate_mode;

/*
    State transitions between above modes -

view all matches for this distribution

Barcode-DataMatrix

1 match

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

Baseball-Sabermetrics

1 match

use 5.004;
use strict 'vars';

use vars qw{$VERSION};
BEGIN {
    # All Module::Install core packages now require synchronised versions.
    # This will be used to ensure we don't accidentally load old or
    # different versions of modules.
    # This is not enforced yet, but will be some time in the next few
    # releases once we can make sure it won't clash with custom
    # Module::Install extensions.

view all matches for this distribution

Bb-Collaborate-Ultra

1 match

use File::Find ();
use File::Path ();

use vars qw{$VERSION $MAIN};
BEGIN {
	# All Module::Install core packages now require synchronised versions.
	# This will be used to ensure we don't accidentally load old or
	# different versions of modules.
	# This is not enforced yet, but will be some time in the next few
	# releases once we can make sure it won't clash with custom
	# Module::Install extensions.

view all matches for this distribution

Bb-Collaborate-V3

1 match