File Coverage

lib/Flux/Storage/Memory.pm

Criterion	Covered	Total	%
statement	51	53	96.2
branch	2	4	50.0
condition	4	4	100.0
subroutine	15	15	100.0
pod	0	5	0.0
total	72	81	88.8

package Flux::Storage::Memory;
{
  $Flux::Storage::Memory::VERSION = '1.03';
}

# ABSTRACT: in-memory storage with support for named clients

use Moo;
with
    'Flux::Out::Role::Easy',
    'Flux::Storage',
    'Flux::Storage::Role::ClientList';

use Carp;
use Flux::Storage::Memory::In;
use List::Util qw(sum);

has 'data' => (
    is => 'ro',
    default => sub { [] },
);

has 'client_pos' => (
    is => 'ro',
    default => sub { {} },
);

has 'client_lock' => (
    is => 'ro',
    default => sub { {} },
);

sub write {
    my $self = shift;
    my ($item) = @_;

    push @{ $self->data }, $item;
}

sub _read {
    my $self = shift;
    my ($pos) = @_;

    return $self->data->[$pos];
}

sub _lag {
    my $self = shift;
    my ($pos) = @_;

    return sum(map { length } @{$self->data}[ $pos .. @{$self->data} - 1 ]) || 0;
}

sub _lock_client {
    my $self = shift;
    my ($client) = @_;

    my $lock = $self->client_lock->{$client};
    if ($lock) {
        # already locked
        return 0;
    }
    $self->client_lock->{$client} = 1;
    return 1;
}

sub _unlock_client {
    my $self = shift;
    my ($client) = @_;

    $self->client_lock->{$client} = 0;
}

sub _get_client_pos {
    my $self = shift;
    my ($client) = @_;

    return $self->client_pos->{$client} || 0;
}

sub _set_client_pos {
    my $self = shift;
    my ($client, $pos) = @_;

    $self->client_pos->{$client} = $pos;
}

sub client_names {
    my $self = shift;
    return keys %{ $self->client_pos };
}

sub register_client {
    my $self = shift;
    my ($name) = @_;

    $self->client_pos->{$name} = 0;
}

sub unregister_client {
    my $self = shift;
    my ($name) = @_;

    delete $self->client_pos->{$name};
    delete $self->client_lock->{$name};
}

sub in {
    my $self = shift;
    my ($client) = @_;

    unless ($self->_lock_client($client)) {
        croak "Constructing two clients with same name '$client' for one MemoryStorage - not implemented yet";
    }
    return Flux::Storage::Memory::In->new({
        storage => $self,
        client => $client,
    });
}

1;

__END__