xDash::Spool::Dummy - Base class for Spool

 package Spool;
 # Test settings:
 use base xDash::Spool::Dummy;
 sub SetParameters { shift->SUPER::SetParameters( 
  event_limit => 10, mean_interoccurence_time => 1 )

package xDash::Spool::Dummy;
# Copyright 2005 Jerzy Wachowiak

use strict;
use warnings;
use vars qw( $VERSION );
use Carp;

$VERSION = '1.00';

# PUBLIC METHODS (convention: capital first letter)

sub new {

    my $class = shift;
    my $self = {};
    $self->{VERSION} = $VERSION;
    $self->{last_time} = time();
    $self->{interval} = 0.0;
    $self->{threads_counter} = 0;
    $self->{threads} = {};
    bless ( $self, $class );
    return $self
}

sub SetParameters {

#Contract: 
#	[1] Parameters as input
#	[2] Method checks if all needed paramters are set
#       [2] Method can suceeds when path formal argument is passed

    my $self = shift;

   $self->{parameters} = { @_ };
    unless ( defined( $self->{parameters}->{event_limit} ) ){
	croak 'xDash: Missing event limit in Spool->SetParameters().'
    }
    unless ( $self->{parameters}->{event_limit} >= 1 ){
	croak 'xDash: Event limit should be greater equal 1'
	.' in Spool->SetParameters().'
    }
    unless ( defined( $self->{parameters}->{mean_interoccurence_time} ) ){
	croak 'xDash: Missing event mean interoccurence time'
	.' in Spool->SetParameters().'
    }
    unless ( $self->{parameters}->{mean_interoccurence_time} > 0 ){
	croak 'xDash: Event mean interoccurence time should be greater 0'
	.' in Spool->SetParameters().'
    }
    return 1
}

sub Check {

#Contract: 
#	[1] No input parameters  
#       [2] If method suceeds a list of threads is returned
#	 (if nothing in the spool -> empty list)
#	[3] If error occours, an error hash is returned

    my $self = shift;
    
    my @threads = keys %{ $self->{threads} };
    if ( $self->{threads_counter} >= $self->{parameters}->{event_limit} ){
	return { threads => \@threads }
    }
    
    my $current_time = time();
    my $delta_time = $current_time - $self->{last_time};
    $self->{last_time} = $current_time;

    while ( 1 ) {
	# Poisson/exponential time series simulation...
	my $interoccurence_time
	 = -log( 1.0 - rand ) * $self->{parameters}->{mean_interoccurence_time};

	if ( $self->{interval} + $interoccurence_time < $delta_time ){
	    if ( $self->{threads_counter}++ 
	     >= $self->{parameters}->{event_limit} ){
		return { threads => \@threads }
	    }
	    $self->{threads}->{ $self->{threads_counter} } = undef;
	    push( @threads, $self->{threads_counter} );
	    $self->{interval} = $interoccurence_time + $self->{interval}
	}
	else {
	    $self->{interval} = $interoccurence_time - $self->{interval};
	    return { threads => \@threads }
	}
    }
}

sub Fetch {

#Contract: 
#	[1] Thread from spool as an input parameter  
#       [2] If method suceeds a hash with only body of the thread is returned
#	 (if nothing empty string '')
#	[3] If error occours, an error hash is returned
#	[4] For own handling should be overwriten
#	[5] $self->{threads}->{$thread} simulates thread body persistence
	
    my $self = shift;	
    my $thread = shift;

    unless ( defined $self->{threads}->{$thread} ){
	$self->{threads}->{$thread} = 'For own generating the body for'
	 ." thread $thread look inside xDash::Spool::Dummy"
	 .' and overwrite Fetch().'
    }
    return { body => $self->{threads}->{$thread} }
}

sub Remove { 

#Contract: 
#	[1] Thread from spool as an input parameter
#	[2] undef always returned

    my $self = shift;	
    my $thread = shift;

    delete $self->{threads}->{$thread};
    return 
}

sub Connect { return }
#Contract: 
#	[1] Not implemented
#	[2] undef always returned

sub Disconnect { return }
#Contract: 
#	No implementation needed for Dir.pm
#	No return value check in the xDash::Sender

1;
__END__
######################## User Documentation ##################