view release on metacpan or  search on metacpan

lib/Data/Rand.pm  view on Meta::CPAN

    sub {
        my ($length) = @_;
        return Crypt::Random::makerandom_itv( 'Lower' => 0, 'Upper' => $length, ...); 
    }

Note: The above example (w/ Strong => 0 (IE read() is not being blocked on /dev/random)) benchmarked appx 570 times as slow as the default L<rand>() based solution but its much more truly random.

=back

=back

 view release on metacpan or  search on metacpan

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

blockage's
blockages
blockbuster
blockbuster's
blockbusters
blocked
blockhead
blockhead's
blockheads
blockhouse
blockhouse's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

cloche
cloche's
cloches
clock
clock's
clocked
clocking
clocks
clockwise
clockwork
clockwork's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

deadliness
deadliness's
deadlining
deadlock
deadlock's
deadlocked
deadlocking
deadlocks
deadly
deadpan
deadpanned

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

floaters
floating
floats
flock
flock's
flocked
flocking
flocks
floe
floe's
floes

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

griding
gridiron
gridiron's
gridirons
gridlock
gridlocked
gridlocking
gridlocks
grids
grief
grief's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

interlink
interlinked
interlinking
interlinks
interlock
interlocked
interlocking
interlocks
interlocutory
interloper
interloper's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

landing's
landings
landladies
landlady
landlady's
landlocked
landlord
landlord's
landlords
landlubber
landlubber's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

loci
loci's
lock
lock's
lockable
locked
locker
locker's
lockers
locket
locket's

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

paddocks
paddy
paddy's
padlock
padlock's
padlocked
padlocking
padlocks
padre
padre's
padres

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

roadbed
roadbed's
roadbeds
roadblock
roadblock's
roadblocked
roadblocking
roadblocks
roadhouse
roadhouse's
roadhouses

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

unbidden
unbind
unbinding
unbinds
unblock
unblocked
unblocking
unblocks
unblushing
unbolt
unbolted

lib/Data/Random/Contact/Language/EN.pm  view on Meta::CPAN

unload
unloaded
unloading
unloads
unlock
unlocked
unlocking
unlocks
unloose
unloosed
unlooses

 view release on metacpan or  search on metacpan

lib/Data/Random/dict  view on Meta::CPAN

blockaded
blockades
blockading
blockage
blockages
blocked
blocker
blockers
blockhouse
blockhouses
blocking

lib/Data/Random/dict  view on Meta::CPAN

clobber
clobbered
clobbering
clobbers
clock
clocked
clocker
clockers
clocking
clockings
clocks

lib/Data/Random/dict  view on Meta::CPAN

dead
deaden
deadline
deadlines
deadlock
deadlocked
deadlocking
deadlocks
deadly
deadness
deadwood

lib/Data/Random/dict  view on Meta::CPAN

floated
floater
floating
floats
flock
flocked
flocking
flocks
flog
flogging
flood

lib/Data/Random/dict  view on Meta::CPAN

locator
locators
loci
lock
Locke
locked
locker
lockers
Lockhart
Lockheed
Lockian

lib/Data/Random/dict  view on Meta::CPAN

unbecoming
unbelievable
unbiased
unbind
unblock
unblocked
unblocking
unblocks
unborn
unbound
unbounded

lib/Data/Random/dict  view on Meta::CPAN

unload
unloaded
unloading
unloads
unlock
unlocked
unlocking
unlocks
unlucky
unmanageable
unmanageably

 view release on metacpan or  search on metacpan

lib/Data/RecordStore.pm  view on Meta::CPAN

    }
    $self->_unlock;
} #delete_record

# locks the given lock names
# they are locked in order to prevent deadlocks.
sub lock {
    my( $self, @locknames ) = @_;

    my( %previously_locked ) = ( map { $_ => 1 } @{$self->[LOCKS]} );

    if( @{$self->[LOCKS]} && grep { ! $previously_locked{$_} } @locknames ) {
        die "Data::RecordStore->lock cannot be called twice in a row without unlocking between";
    }
    my $fhs = [];

    my $failed;

    for my $name (sort @locknames) {
        next if $previously_locked{$name}++;
        my $lockfile = "$self->[DIRECTORY]/user_locks/$name";
        my $fh;
        if( -e $lockfile ) {
            unless( open ( $fh, '+<', $lockfile ) ) {
                $failed = 1;

lib/Data/RecordStore.pm  view on Meta::CPAN

}

sub _fix_transactions {
    my $self = shift;
    # check the transactions
    # if the transaction is in an incomplete state, fix it. Since the store is write locked
    # during transactions, the lock has expired if this point has been reached.
    # that means the process that made the lock has fallen.
    #
    # of course, do a little experiment to test this with two processes and flock when
    # one exits before unflocking.

lib/Data/RecordStore.pm  view on Meta::CPAN

This may not be called twice in a row without an unlock in between
and will die if that happens.

=head2 unlock

Unlocks all names locked by this thread

=head2 use_transaction()

Returns the current transaction. If there is no
current transaction, it creates one and returns it.

 view release on metacpan or  search on metacpan

Shared.xs  view on Meta::CPAN

        items_buf = (void *)malloc((size_t)count * sizeof(*items_buf));
        if (!items_buf) croak("Data::ReqRep::Shared: out of memory");
    }
    reqrep_mutex_lock(h->hdr);
    for (UV i = 0; i < count; i++) {
        last_r = reqrep_recv_locked(h, &str, &len, &utf8, &id);
        if (last_r <= 0) break;
        char *c = (char *)malloc(len ? len : 1);
        if (!c) { oom = 1; break; }
        if (len) memcpy(c, str, len);
        items_buf[n].buf = c;

Shared.xs  view on Meta::CPAN

        items_buf = (void *)malloc((size_t)(count - 1) * sizeof(*items_buf));
        if (!items_buf) croak("Data::ReqRep::Shared: out of memory");
    }
    reqrep_mutex_lock(h->hdr);
    for (UV i = 1; i < count; i++) {
        last_r2 = reqrep_recv_locked(h, &str, &len, &utf8, &id);
        if (last_r2 <= 0) break;
        char *c = (char *)malloc(len ? len : 1);
        if (!c) { oom = 1; break; }
        if (len) memcpy(c, str, len);
        items_buf[n].buf = c;

Shared.xs  view on Meta::CPAN

    UV drained_n = 0;
    int last_r = 0;
    int oom = 0;
    reqrep_mutex_lock(h->hdr);
    while (max_count-- > 0) {
        last_r = reqrep_recv_locked(h, &str, &len, &utf8, &id);
        if (last_r <= 0) break;
        struct drain_item *it = (struct drain_item *)malloc(sizeof(*it));
        char *c = (char *)malloc(len ? len : 1);
        if (!it || !c) { free(it); free(c); oom = 1; break; }
        if (len) memcpy(c, str, len);

 view release on metacpan or  search on metacpan

ring.h  view on Meta::CPAN

    uint64_t seq_off;          /* 40: offset to per-slot publication seq array */
    uint8_t  _pad0[16];        /* 48-63 */

    uint64_t head;             /* 64: monotonic write cursor (next write position) */
    uint64_t count;            /* 72: total writes (for overwrite detection) */
    uint32_t waiters;          /* 80: blocked on new data */
    uint32_t wake_seq;         /* 84: FUTEX_WAIT target (avoids 64-bit count wraparound) */
    uint64_t stat_writes;      /* 88 */
    uint64_t stat_overwrites;  /* 96 */
    uint8_t  _pad2[24];        /* 104-127 */
} RingHeader;

 view release on metacpan or  search on metacpan

lib/Data/Rlist.pm  view on Meta::CPAN

    $attr = '-'.$attr unless $attr =~ /^-/;
    exists $self->{$attr};
}

sub dock($\&) {
    carp "package Data::Rlist locked" if $Locked++; # TODO: use critical sections and atomic increment
    my ($self, $block) = @_;
    local $MaxDepth = $self->get(-MaxDepth=>) if $self->has(-MaxDepth=>);
    local $SafeCppMode = $self->get(-SafeCppMode=>) if $self->has(-SafeCppMode=>);
    local $EchoStderr = $self->get(-EchoStderr=>) if $self->has(-EchoStderr=>);
    local $RoundScientific = $self->get(-RoundScientific=>) if $self->has(-RoundScientific=>);

lib/Data/Rlist.pm  view on Meta::CPAN

    unless (defined $thing) {
        if ($object->errors) {
            print STDERR "$thingfile has syntax errors"
        } else {
            print STDERR "$thingfile not found, is locked or empty"
        }
    } else {
        # Can use $thing
            .
            .

lib/Data/Rlist.pm  view on Meta::CPAN

    my($input, $fcmd, $fcmdargs) = @_;
    my($rls, $filename);
    my $rtp = reftype $input;

    carp "\n${\((caller(0))[3])}: filename or scalar-ref required as INPUT" if defined $rtp && $rtp ne 'SCALAR';
    carp "\n${\((caller(0))[3])}: package locked" if $Readstruct;
    $Readstruct = $ReadFh = undef;
    local $| = 1 if $DEBUG;

    if (defined $input) {
        $Readstruct = { };

lib/Data/Rlist.pm  view on Meta::CPAN

    ERROR: compile2() broken in deep ARRAY(0x101aaeec) (depth = 101, max-depth = 100)

This  message will  also be  repeated as  comment when  the compiled  Rlist is  written to  a file.
Furthermore  F<$Data::Rlist::Broken>  is  incremented  by  one. While  the  compilation  continues,
effectively  any  attempt to  venture  deeper as  suggested  by  F<$Data::Rlist::MaxDepth> will  be
blocked.

See F<L</broken>>.

=head2 Speeding up Compilation (Explicit Quoting)

 view release on metacpan or  search on metacpan

t/Data/File/Package.pm  view on Meta::CPAN

         # The eval messes with the stack. Since not using an eval, need
         # to double check to make sure import does not die.
         
         ####
         # Poor man's eval where trap off the Carp::croak function.
         # The Perl authorities have Core::die locked down tight so
         # it is next to impossible to trap off of Core::die. Lucky 
         # must everyone uses Carp::croak instead of just dieing.
         #
         # Anyway, get the benefit of a lot of stack gyrations to
         # formulate the correct error msg by Exporter::import.

 view release on metacpan or  search on metacpan

t/Data/File/Package.pm  view on Meta::CPAN

         # The eval messes with the stack. Since not using an eval, need
         # to double check to make sure import does not die.
         
         ####
         # Poor man's eval where trap off the Carp::croak function.
         # The Perl authorities have Core::die locked down tight so
         # it is next to impossible to trap off of Core::die. Lucky 
         # must everyone uses Carp::croak instead of just dieing.
         #
         # Anyway, get the benefit of a lot of stack gyrations to
         # formulate the correct error msg by Exporter::import.

 view release on metacpan or  search on metacpan

lib/Data/Session/Driver/BerkeleyDB.pm  view on Meta::CPAN

=head1 Method: traverse()

Retrieves all ids via a cursor, and for each id calls the supplied subroutine with the id as the
only parameter.

The database is not locked during this process.

Returns 1.

=head1 Installing BerkeleyDB

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu

ppport.h  view on Meta::CPAN

PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu

ppport.h  view on Meta::CPAN

putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p

 view release on metacpan or  search on metacpan

lib/Data/Stack/Shared.pm  view on Meta::CPAN

slot transitions during the read and returns false if the top changes
concurrently beyond the retry budget.

C<drain> is safe under concurrent C<push>/C<pop>, but it spin-waits on
slots whose pusher is mid-publish; a pusher crash between its position
CAS and the publish leaves drain blocked on that slot. Use C<drain> for
orderly draining, not as a crash-recovery primitive.

=head2 Compatibility

File format bumped to v2 in this release (per-slot control array added

 view release on metacpan or  search on metacpan

Data/Stag.pm  view on Meta::CPAN

=head3 chainhandler

       Title: chainhandler

        Args: blocked events - str or str[]
              initial handler - handler object
              final handler - handler object
     Returns: 
     Example: $h = Data::Stag->chainhandler('foo', $processor, 'xml')

Data/Stag.pm  view on Meta::CPAN

                                       );
  $chainh = Data::Stag->chainhandler(['a', 'b'], $processor, 'xml');
  $stag = Data::Stag->parse(-str=>"(...)", -handler=>$chainh)

If the inner handler has a method CONSUMES(), this method will
determine the blocked events if none are specified.

see also the script B<stag-handle.pl>


=head2  RECURSIVE SEARCHING

 view release on metacpan or  search on metacpan

t/Data/File/Package.pm  view on Meta::CPAN

         # The eval messes with the stack. Since not using an eval, need
         # to double check to make sure import does not die.
         
         ####
         # Poor man's eval where trap off the Carp::croak function.
         # The Perl authorities have Core::die locked down tight so
         # it is next to impossible to trap off of Core::die. Lucky 
         # must everyone uses Carp::croak instead of just dieing.
         #
         # Anyway, get the benefit of a lot of stack gyrations to
         # formulate the correct error msg by Exporter::import.

 view release on metacpan or  search on metacpan

t/Data/File/Package.pm  view on Meta::CPAN

         # The eval messes with the stack. Since not using an eval, need
         # to double check to make sure import does not die.
         
         ####
         # Poor man's eval where trap off the Carp::croak function.
         # The Perl authorities have Core::die locked down tight so
         # it is next to impossible to trap off of Core::die. Lucky 
         # must everyone uses Carp::croak instead of just dieing.
         #
         # Anyway, get the benefit of a lot of stack gyrations to
         # formulate the correct error msg by Exporter::import.

 view release on metacpan or  search on metacpan

eg/guard.pl  view on Meta::CPAN

    {
        my $g = $cv->lock_guard;
        print "cv: lock_guard held\n";
    }
    # Prove it unlocked by locking again
    $cv->lock;
    $cv->unlock;
    print "cv: lock_guard released correctly\n\n";
}

 view release on metacpan or  search on metacpan

lib/Data/Table/Text.pm  view on Meta::CPAN

    @l = @L;
   }
  confess "Expansion too deep";
 } # includeFiles

sub appendFile($$)                                                              # Append to B<$file> a B<$string> of L<unicode> content encoded with L<utf8>, creating the $file first if necessary. Return the name of the $file on success else confess....
 {my ($file, $string) = @_;                                                     # File to append to, string to append
  $file or confess "No file name supplied\n";
  $string or carp "No string for file:\n$file\n";
  makePath($file);
  open my $F, ">>$file" or

lib/Data/Table/Text.pm  view on Meta::CPAN

   }


=head3 appendFile  ($file, $string)

Append to B<$file> a B<$string> of L<Unicode|https://en.wikipedia.org/wiki/Unicode> content encoded with L<utf8|https://en.wikipedia.org/wiki/UTF-8>, creating the $file first if necessary. Return the name of the $file on success else confess. The $fi...

     Parameter  Description
  1  $file      File to append to
  2  $string    String to append

 view release on metacpan or  search on metacpan

t/002File.t  view on Meta::CPAN

    db_file   => $file,
);

is($throttler->try_push(), 1, "1st item in");
is($throttler->try_push(), 1, "2nd item in");
is($throttler->try_push(), 0, "3nd item blocked");

my $throttler2 = Data::Throttler->new(
    max_items => 999,
    interval  => 1235,
    db_file   => $file,

t/002File.t  view on Meta::CPAN

    db_file   => $file,
    reset     => 1,
);
is($throttler3->try_push(), 1, "1st item in");
is($throttler3->try_push(), 1, "2nd item in");
is($throttler3->try_push(), 0, "3rd item blocked");

# Reload test
my $throttler4 = Data::Throttler->new(
    max_items => 2,
    interval  => 60,
    db_file   => $file,
);
is($throttler4->try_push(), 0, "item blocked after reload");
is($throttler4->reset_key(), 2, "resetting key returned expected value");
is($throttler4->try_push(), 1, "item allowed after resetting key");
is($throttler4->reset_key(), 1, "resetting key returned expected value");

};

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu

ppport.h  view on Meta::CPAN

PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu

ppport.h  view on Meta::CPAN

putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p

 view release on metacpan or  search on metacpan

t/vg  view on Meta::CPAN

pc^outforce, the^strategy first, inc.^infinite loop^real-time strategy^8^t (teen)^01/04/2001
pc^outlaw chopper^vivendi universal^jarhead games^action^1^m (mature)^07/11/2006
pc^outlive^take 2 interactive^continuum entertainment^real-time strategy^16^t (teen)^03/20/2001
pc^outrun 2006: coast 2 coast^sega^sumo digital^racing, driving^6^e (everyone)^05/09/2006
pc^over the hedge^activision^beenox^action, platform^2^e10+ (everyone 10 and older)^05/09/2006
pc^overclocked: a history of violence^anaconda / lighthouse interactive^house of tales^adventure^1^m (mature)^04/07/2008
pc^overlord^codemasters^triumph studios^action, adventure^1^t (teen)^06/26/2007
pc^pacific fighters^ubisoft^1c - maddox games^combat flight simulation^128^t (teen)^10/22/2004
pc^pacific storm^buka entertainment^lesta studio^real-time strategy, wargame, simulation^8^t (teen)^09/29/2006
pc^pacific storm: allies^buka entertaiment^lesta studio^real-time strategy, wargame, simulation^8^t (teen)^05/25/2007
pc^pac-man all-stars^infogrames^creature labs^action, platform^4^e (everyone)^05/14/2002

t/vg  view on Meta::CPAN

playstation 2^ratchet & clank: going commando^sony computer entertainment america^insomniac games^action, adventure, platform^1^t (teen)^11/11/2003
playstation 2^ratchet & clank: going commando^sony computer entertainment america^insomniac games^action, adventure, platform^1^t (teen)^11/11/2003
playstation 2^ratchet & clank: size matters^sony computer entertainment america^high impact games^third-person action^2^e10+ (everyone 10 and older)^03/11/2008
playstation 2^ratchet and clank: up your arsenal^sony computer entertainment america^insomniac games^action, adventure, platform^8^t (teen)^11/02/2004
playstation 2^ratchet and clank: up your arsenal^sony computer entertainment america^insomniac games^action, adventure, platform^8^t (teen)^11/02/2004
playstation 2^ratchet: deadlocked^sony computer entertainment america^insomniac games^third-person shooter, action^8^t (teen)^10/25/2005
playstation 2^raw danger^irem / agetec^irem^third-person action, adventure^1^m (mature)^06/12/2007
playstation 2^rayman 2: revolution^ubi soft^ubi soft^action^2^e (everyone)^01/31/2001
playstation 2^rayman 3: hoodlum havoc^ubi soft^ubi soft^action^1^e (everyone)^03/18/2003
playstation 2^rayman arena^ubi soft^ubi soft^action^4^e (everyone)^09/27/2002
playstation 2^rayman raving rabbids^ubisoft^ubisoft montpellier^platform^4^e (everyone)^12/05/2006

 view release on metacpan or  search on metacpan

lib/Database/Schema/Config.pm  view on Meta::CPAN

    	return (undef,$hv);
}

=head2 isConfigLocked()

Check to see if the latest config is currently locked. If it is, return information about the lock.

  $cfg->isConfigLocked();

Returns

  (errstr,undef) on failure
  (undef,HASHREF) locked. see keys for details.
  (undef,0) not locked

=cut

sub isConfigLocked {
    	my $self = shift;

lib/Database/Schema/Config.pm  view on Meta::CPAN

   	my $sql = 'SELECT rev, user FROM config WHERE xlock = 1';
    	my $rv  = $self->dbh->selectall_arrayref($sql);

	return ('db failure: '.$self->dbh->errstr(),undef) unless($rv);
        return ('multiple locks on config detected.',undef) if(@$rv > 1);
    	return ('config is not locked',0) if(@$rv == 0);  # no locks
    	return (undef,{
		'rev'  => $rv->[0]->[0],
             	'user' => $rv->[0]->[1],
	});
}

=head2 lockConfig()

Lock the configuration so other people know we are editting it. A note will be appended to the "log" for the configuration.  The latest configuration will be "locked" unless "rev" is specified. This should be called from the getConfig() method, not d...

Accepts:

  -rev => [int], defaults to 0
  -user => [string],

lib/Database/Schema/Config.pm  view on Meta::CPAN

  $cfg->lockConfig(-rev => $rev, -user => $username);

Returns:

  (errstr,undef) on failure
  ('lock failed',0) if already locked
  (undef,$rev) on success

=cut

sub lockConfig {

lib/Database/Schema/Config.pm  view on Meta::CPAN

	my $err;
    	($err,$rv) = $self->appendLogToConfig(
		-rev => $r,
		-user => $u,
		-log => ['config locked'],
	);
	return ($err,$rv) unless($rv);
    	return (undef,$r);
}

lib/Database/Schema/Config.pm  view on Meta::CPAN

	return ($err,$rv) unless($rv);

	($err,$rv) = $self->appendLogToConfig(
		-rev => $r,
		-user => $u,
		-log => ['config unlocked'],
	);
    	return ($err,$rv) unless($rv);

    	my $sql = 'UPDATE config SET xlock = 0 WHERE rev = '.$self->dbh->quote($r).' AND user = '.$self->dbh->quote($u);
    	$rv = $self->dbh->do($sql);

lib/Database/Schema/Config.pm  view on Meta::CPAN

		return ('db failure: '.$self->dbh->errstr(),undef) unless($rv);
	}
	else {
		my $hr = $self->isConfigLocked();
		return ('no lock on previous config',undef) unless(ref($hr) eq 'HASH');
		return ('Someone else has already locked this config: user='.$hr->{user}.' rev='.$hr->{rev},undef) if($hr->{user} ne $u);
	}

	my $ts = Time::Timestamp->new(ts => time());
	my $sql = 'INSERT INTO `'.$self->table().'` (rev,dt,user,config) VALUES (?,?,?,?)';
	my $sth = $self->dbh->prepare($sql);

 view release on metacpan or  search on metacpan

Sophia-src/db/recover.c  view on Meta::CPAN

	int rc = sp_lockfile(&s->lockdb, path);
	if (spunlikely(rc == -1))
		sp_e(s, SPE, "failed to create lock file (errno: %d, %s)",
		     errno, strerror(errno));
	if (rc == 1)
		return sp_e(s, SPE, "database is locked");
	/* within a single process, add database path to the list and
	 * check the presence on a open. */
	sp_lock(&dirlock);
	if (dirlockn == 0) {
		sp_listinit(&dirlocks);

Sophia-src/db/recover.c  view on Meta::CPAN

		splist *i;
		sp_listforeach(&dirlocks, i) {
			spdirlock *l = spcast(i, spdirlock, link);
			if (! strcmp(s->env->dir, l->dir)) {
				sp_unlock(&dirlock);
				return sp_e(s, SPE, "database is locked");
			}
		}
	}
	int lendir = strlen(s->env->dir) + 1;
	int len = sizeof(spdirlock) + lendir;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    [Bug Fixes]
    * The "%s" format specifier now always returns the same value as the
      epoch method, regardless of what the underlying implementation thinks

    [Distro Fixes]
    * Fixed `strftime` unit tests being locked to the author's timezone
      github #6 (thx Slaven Rezić (SREZIC))
    * Removed check for "%p" in `strftime` test because it's locale-specific
      github #7 (thx Slaven Rezić (SREZIC))

0.01_02   2016-05-22 01:48:55PDT-0700 America/Los_Angeles (TRIAL RELEASE)

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu

ppport.h  view on Meta::CPAN

PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu

ppport.h  view on Meta::CPAN

putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu

ppport.h  view on Meta::CPAN

PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu

ppport.h  view on Meta::CPAN

putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

get_av|5.006000|5.003007|p
getc|5.003007||Viu
get_c_backtrace|5.021001||Vi
get_c_backtrace_dump|5.021001||V
get_context|5.006000|5.006000|nu
getc_unlocked|5.003007||Viu
get_cv|5.006000|5.003007|p
get_cvn_flags|5.009005|5.003007|p
get_cvs|5.011000|5.003007|p
getcwd_sv|5.007002|5.007002|
get_db_sub|||iu

ppport.h  view on Meta::CPAN

PERL_MALLOC_WRAP|5.009002|5.009002|Vn
PerlMem_calloc|5.006000||Viu
PerlMem_free|5.005000||Viu
PerlMem_free_lock|5.006000||Viu
PerlMem_get_lock|5.006000||Viu
PerlMem_is_locked|5.006000||Viu
PerlMem_malloc|5.005000||Viu
PERL_MEMORY_DEBUG_HEADER_SIZE|5.019009||Viu
PerlMemParse_calloc|5.006000||Viu
PerlMemParse_free|5.006000||Viu
PerlMemParse_free_lock|5.006000||Viu
PerlMemParse_get_lock|5.006000||Viu
PerlMemParse_is_locked|5.006000||Viu
PerlMemParse_malloc|5.006000||Viu
PerlMemParse_realloc|5.006000||Viu
PerlMem_realloc|5.005000||Viu
PerlMemShared_calloc|5.006000||Viu
PerlMemShared_free|5.006000||Viu
PerlMemShared_free_lock|5.006000||Viu
PerlMemShared_get_lock|5.006000||Viu
PerlMemShared_is_locked|5.006000||Viu
PerlMemShared_malloc|5.006000||Viu
PerlMemShared_realloc|5.006000||Viu
PERL_MG_UFUNC|5.007001||Viu
Perl_modf|5.006000|5.006000|n
PERL_MULTICONCAT_HEADER_SIZE|5.027006||Viu

ppport.h  view on Meta::CPAN

putc|5.003007||Viu
put_charclass_bitmap_innards|5.021004||Viu
put_charclass_bitmap_innards_common|5.023008||Viu
put_charclass_bitmap_innards_invlist|5.023008||Viu
put_code_point|5.021004||Viu
putc_unlocked|5.003007||Viu
putenv|5.005000||Viu
put_range|5.019009||Viu
putw|5.003007||Viu
pv_display|5.006000|5.003007|p
pv_escape|5.009004|5.003007|p

 view release on metacpan or  search on metacpan

t/20_accessors.t  view on Meta::CPAN

# Now test that trying to change a parameter value will emit a "croak"
foreach (@accessors) {
    my $accessor = $_->{accessor};
    throws_ok( sub { my $foo = $fc->$accessor( $_->{expect} ) },
        qr/$accessor/, "blocked setting $accessor" );
}

# Now do it all over again using the Empty::Fiscal5253 class to be sure
# this module can be safely sub-classed. A single test of the basic
# constructor would probably suffice, but why not be sure?

t/20_accessors.t  view on Meta::CPAN

}

foreach (@accessors) {
    my $accessor = $_->{accessor};
    throws_ok( sub { my $foo = $fc->$accessor( $_->{expect} ) },
        qr/$accessor/, "blocked setting $accessor" );
}

done_testing();

exit;

 view release on metacpan or  search on metacpan

ctport.h  view on Meta::CPAN

#define BAT_LOK_WRT	0x1000
#define BAT_COMPLETE	0x2000
#define BAT_FLTR	0x4000
#define BAT_LOK_KEEP	0x8000

#define EXCLUSIVE 	0x0000		/* file in locked mode	     */
#define SHARED		0x0001		/* file in shared mode	     */
#define	VIRTUAL		0x0000		/* file is virtually opened  */
#define	PERMANENT	0x0002		/* file is physically opened */
#define	ctFIXED		0x0000		/* fixed length data	     */
#define	VLENGTH		0x0004		/* variable length data	     */

 view release on metacpan or  search on metacpan

GTM.pm  view on Meta::CPAN

  not the stuff that is in the process of being written.

=head3 LOCKING

  $status = $dblink->lock(@name,$seconds);   # Lock a database node
  $status = $dblink->unlock(@name);          # Unlock something locked prior

  seconds: the last parameter to lock() is the number of seconds to
    wait to get a lock before giving up.  This is important as GT.M
    reserves the use of signals for itself and using SIGALRM may 
    cause problems.

GTM.pm  view on Meta::CPAN

  Bad things will happen to you if you don't.

  In order to work gracefully with other processes that are attempting
  to update data in the GTM datastore, you can request locks on database
  nodes.  Locks are advisory (meaning that it's possible to write to a
  "locked" node if you don't bother to ask for your lock first).  Locks
  are automatically released when your process exits.

  Lock on a higher-level resources conflict with lower-level ones.

  Examples:

GTM.pm  view on Meta::CPAN

    (Process 2)  $db = new GTMDB("TOPNODE");
                 $db->lock("MYNODE",0);      # Lock (TOPNODE.MYNODE)
                 # Fails because process 1 has a conflicting lock

  Note that you can always get locks to resources that you have previously
  locked, or lock a lower level resource.

=head2 FUNCTION LIST

  Conventions: 

GTM.pm  view on Meta::CPAN

  $status = $dblink->txnstart();       # Begin a transaction
  $status = $dblink->txnabort();       # Abort a transaction, make no changes
  $status = $dblink->txncommit();      # Save all set/kills made during txn

  $status = $dblink->lock(@name,$seconds);   # Lock a database node
  $status = $dblink->unlock(@name);          # Unlock locked database node

  $status = $db_obj->merge(@srcname [ ,undef,@dstname ]); 
      # Copies nodes in @srcname into @dstname, overwriting collisions 
      # if unspecified, @dstname is assumed to be the main node
   

 view release on metacpan or  search on metacpan

Deliantra.pm  view on Meta::CPAN

   run_away pick_up unique no_drop can_cast_spell can_use_scroll can_use_range
   can_use_bow can_use_armour can_use_weapon can_use_ring has_ready_range
   has_ready_bow xrays is_floor lifesave no_strength sleep stand_still
   random_move only_attack confused stealth cursed damned see_anywhere
   known_magical known_cursed can_use_skill been_applied has_ready_scroll
   can_use_rod can_use_horn make_invisible inv_locked is_wooded is_hilly
   has_ready_skill has_ready_weapon no_skill_ident is_blind can_see_in_dark
   is_cauldron is_dust no_steal one_hit berserk neutral no_attack no_damage
   activate_on_push activate_on_release is_water use_content_on_gen is_buildable
   precious