File Coverage

blib/lib/Inferno/RegMgr/Monitor.pm

Criterion	Covered	Total	%
statement	21	68	30.8
branch	0	18	0.0
condition			n/a
subroutine	7	14	50.0
pod	1	4	25.0
total	29	104	27.8

package Inferno::RegMgr::Monitor;

use warnings;
use strict;
use Carp;

# update POD & Changes & README
use version; our $VERSION = qv('0.1.0');

# update DEPENDENCIES in POD & Makefile.PL & README
use Scalar::Util qw( weaken );
use Inferno::RegMgr::Utils qw( run_callback );

use Inferno::RegMgr::Lookup;


sub new {
    my ($class, $opt) = @_;
    my $self = {
        lookup      => undef,
        cb_add      => $opt->{cb_add},
        cb_del      => $opt->{cb_del},
        cb_mod      => $opt->{cb_mod},
        method_add  => $opt->{method_add},
        method_del  => $opt->{method_del},
        method_mod  => $opt->{method_mod},
        manager     => undef,
        cur         => {},
    };
    bless $self, $class;
    weaken( my $this = $self );
    $self->{lookup} = Inferno::RegMgr::Lookup->new({
        attr    => $opt->{attr},
        cb      => sub { $this->_cb_monitor(@_) },
    });
    return $self;
}

sub START {
    my ($self) = @_;
    $self->{manager}->attach( $self->{lookup} );
    return;
}

sub _cb_monitor {
    my ($self, $svc) = @_;
    my @prev = keys %{ $self->{cur} };
    for my $name (@prev) {
        if (exists $svc->{ $name }) {
            my $attr = delete $svc->{ $name };
            if (_is_differ($self->{cur}{ $name }, $attr)) {
                $self->{cur}{ $name } = $attr;
                if (defined $self->{cb_mod}) {
                    run_callback( $self->{cb_mod}, $self->{method_mod}, $name => $attr );
                }
            }
        }
        else {
            my $attr = delete $self->{cur}{ $name };
            if (defined $self->{cb_del}) {
                run_callback( $self->{cb_del}, $self->{method_del}, $name => $attr );
            }
        }
    }
    for my $name (keys %{ $svc }) {
        my $attr = $svc->{ $name };
        $self->{cur}{ $name } = $attr;
        if (defined $self->{cb_add}) {
            run_callback( $self->{cb_add}, $self->{method_add}, $name => $attr );
        }
    }
    return;
}

sub _is_differ {
    my ($h1, $h2) = @_;
    return 1 if keys %{ $h1 } != keys %{ $h2 };
    for my $key (keys %{ $h1 }) {
        return 1 if !exists $h2->{ $key };
        return 1 if $h1->{ $key } ne $h2->{ $key };
    }
    return 0;
}

sub STOP {
    my ($self) = @_;
    # Inferno::RegMgr::Lookup may already detach itself (after finishing search).
    if ($self->{lookup}{manager}) {
        $self->{manager}->detach( $self->{lookup} );
    }
    return;
}

sub REFRESH {
    my ($self) = @_;
    $self->STOP();
    $self->START();
    return;
}


1; # Magic true value required at end of module
__END__