File Coverage

blib/lib/Data/Sync/Shared.pm

Criterion	Covered	Total	%
statement	41	42	97.6
branch	15	20	75.0
condition	6	8	75.0
subroutine	10	10	100.0
pod	0	5	0.0
total	72	85	84.7

package Data::Sync::Shared;
use strict;
use warnings;
our $VERSION = '0.04';

require XSLoader;
XSLoader::load('Data::Sync::Shared', $VERSION);

# Guard objects — auto-release on scope exit

package Data::Sync::Shared::RWLock::Guard {
    sub DESTROY {
        my $self = shift;
        $self->[0]->${\$self->[1]} if $self->[0];
    }
}

sub Data::Sync::Shared::RWLock::rdlock_guard {
    my $self = shift;
    $self->rdlock(@_);
    bless [$self, 'rdunlock'], 'Data::Sync::Shared::RWLock::Guard';
}

sub Data::Sync::Shared::RWLock::wrlock_guard {
    my $self = shift;
    $self->wrlock(@_);
    bless [$self, 'wrunlock'], 'Data::Sync::Shared::RWLock::Guard';
}

package Data::Sync::Shared::Condvar::Guard {
    sub DESTROY {
        my $self = shift;
        $self->[0]->unlock if $self->[0];
    }
}

sub Data::Sync::Shared::Condvar::lock_guard {
    my $self = shift;
    $self->lock;
    bless [$self], 'Data::Sync::Shared::Condvar::Guard';
}

# Condvar wait_while — loop until predicate returns false

sub Data::Sync::Shared::Condvar::wait_while {
    my ($self, $pred, $timeout) = @_;
    $timeout //= -1;
    return $pred->() ? 0 : 1 if $timeout == 0;
    my $deadline;
    if ($timeout > 0) {
        require Time::HiRes;
        $deadline = Time::HiRes::time() + $timeout;
    }
    while ($pred->()) {
        if (defined $deadline) {
            my $remaining = $deadline - Time::HiRes::time();
            return 0 if $remaining <= 0;
            $self->wait($remaining);
            # Fall through to re-check predicate even on timeout — the
            # condition may have cleared just before our deadline expired.
        } else {
            $self->wait;
        }
    }
    return 1;
}

# Semaphore guard

sub Data::Sync::Shared::Semaphore::acquire_guard {
    my ($self, $n, $timeout) = @_;
    $n //= 1;
    if ($n == 1) {
        $self->acquire($timeout // -1) or return undef;
    } else {
        $self->acquire_n($n, $timeout // -1) or return undef;
    }
    bless [$self, $n], 'Data::Sync::Shared::Semaphore::Guard';
}

package Data::Sync::Shared::Semaphore::Guard {
    sub DESTROY {
        my $self = shift;
        $self->[0]->release($self->[1]);
    }
}

1;

__END__