File Coverage

blib/lib/Spread/Messaging.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package Spread::Messaging;

use 5.008;
use strict;
use warnings;

require Exporter;
use Spread::Messaging::Content;
use Spread::Messaging::Exception;

our @ISA = qw(Exporter Spread::Messaging::Content);

our $VERSION = '0.03';

our @EXPORT = qw(
 UNRELIABLE_MESS
 RELIABLE_MESS
 FIFO_MESS
 CAUSAL_MESS
 AGREED_MESS
 SAFE_MESS
);

# ------------------------------------------------------------------------
# public methods
# ------------------------------------------------------------------------

sub new {
    my $class = shift;
    my $self = $class->SUPER::new(@_);

    $self->{entity} = "";
    $self->{joined_groups} = undef;
    $self->{callback_private} = undef;
    $self->{callback_group} = undef;
    $self->{callback_join} = undef;
    $self->{callback_leave} = undef;
    $self->{callback_disconnect} = undef;
    $self->{callback_network} = undef;
    $self->{callback_transition} = undef;
    $self->{callback_other} = undef;

    return $self;

}

sub callbacks {
    my $self = shift;
    my %params = @_;

    my ($k, $v);
    local $_;

    if (defined($v = delete $params{'-private'})) {

        $self->{callback_private} = $v;

    }

    if (defined($v = delete $params{'-group'})) {

        $self->{callback_group} = $v;

    }

    if (defined($v = delete $params{'-join'})) {

        $self->{callback_join} = $v;

    }

    if (defined($v = delete $params{'-leave'})) {

        $self->{callback_leave} = $v;

    }

    if (defined($v = delete $params{'-disconnect'})) {

        $self->{callback_disconnect} = $v;

    }

    if (defined($v = delete $params{'-network'})) {

        $self->{callback_network} = $v;

    }

    if (defined($v = delete $params{'-transition'})) {

        $self->{callback_transition} = $v;

    }

    if (defined($v = delete $params{'-other'})) {

        $self->{callback_other} = $v;

    }

}

sub process {
    my ($self) = @_;

    $self->SUPER::recv();

    if ($self->is_regular_mess) {

        if ($self->is_private_mess) {

            $self->entity($self->sender);
            return $self->{callback_private}->($self)
                   if defined $self->{callback_private};

        } else {

            $self->entity($self->sender);
            return $self->{callback_group}->($self)
                   if defined $self->{callback_group};

        }

    } elsif ($self->is_membership_mess) {

        if ($self->is_reg_memb_mess) {

            if ($self->is_caused_by_join) {

                $self->entity(@{$self->message}[3]);
                _do_groups($self);
                return $self->{callback_join}->($self)
                       if defined $self->{callback_join};

            } elsif ($self->is_caused_by_leave) {

                $self->entity(@{$self->message}[3]);
                _do_groups($self);
                return $self->{callback_leave}->($self)
                       if defined $self->{callback_leave};

            } elsif ($self->is_caused_by_disconnect) {

                $self->entity(@{$self->message}[3]);
                _do_groups($self);
                return $self->{callback_disconnect}->($self)
                       if defined $self->{callback_disconnect};

            } elsif ($self->is_caused_by_network) {

                $self->entity("");
                return $self->{callback_network}->($self)
                       if defined $self->{callback_network};

            }

        } elsif ($self->is_transition_mess) {

            $self->entity("");
            return $self->{callback_transition}->($self)
                   if defined $self->{callback_transition};

        }

    } else {

        $self->entity("");
        return $self->{callback_other}->($self)
               if defined $self->{callback_other};

    }

}

# ------------------------------------------------------------------------
# public accessors
# ------------------------------------------------------------------------

sub entity {
    my ($self, $p) = @_;

    $self->{entity} = $p if defined $p;
    return($self->{entity});

}

sub groups_joined {
    my ($self) = @_;

    my @groups;

    foreach my $group (@{$self->{joined_groups}}) {

        push(@groups, $group->{name});

    }

    return @groups;

}

sub group_members {
    my ($self, $name) = @_;

    my @groups;

    foreach my $group (@{$self->{joined_groups}}) {

        if ($group->{name} =~ /$name/i) {

            @groups = split(',', $group->{members});
            return @groups;

        }

    }

    return undef;

}

# ------------------------------------------------------------------------
# private functions
# ------------------------------------------------------------------------

sub _do_groups {
    my ($self) = @_;

    my ($groups, $x);

    $x = 0;
    $groups->{name} = $self->sender;
    $groups->{members} = join(',', @{$self->group});

    foreach my $group (@{$self->{joined_groups}}) {

        if ($group->{name} eq $groups->{name}) {

            @{$self->{joined_groups}}[$x] = $groups;
            return;

        }

        $x++;

    }

    push(@{$self->{joined_groups}}, $groups);

}

1;

__END__