File Coverage

blib/lib/Bloom/Faster.pm

Criterion	Covered	Total	%
statement	41	71	57.7
branch	7	14	50.0
condition	1	6	16.6
subroutine	12	21	57.1
pod	0	12	0.0
total	61	124	49.1

package Bloom::Faster;

use 5.008005;
use strict;
use warnings;
use Carp;

require Exporter;
use AutoLoader;

our @ISA = qw(Exporter);

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

# This allows declaration	use Bloom ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
our %EXPORT_TAGS = ( 'all' => [ qw(
	HASHCNT
	SET
) ] );

our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );

our @EXPORT = qw(
	HASHCNT
	SET
);


sub AUTOLOAD {
    # This AUTOLOAD is used to 'autoload' constants from the constant()
    # XS function.

    my $constname;
    our $AUTOLOAD;
    ($constname = $AUTOLOAD) =~ s/.*:://;
    croak "&Bloom::constant not defined" if $constname eq 'constant';
    my ($error, $val) = constant($constname);
    if ($error) { croak $error; }
    {
	no strict 'refs';
	# Fixed between 5.005_53 and 5.005_61
#XXX	if ($] >= 5.00561) {
#XXX	    *$AUTOLOAD = sub () { $val };
#XXX	}
#XXX	else {
	    *$AUTOLOAD = sub { $val };
#XXX	}
    }
    goto &$AUTOLOAD;
}


our $VERSION = '1.7';


require XSLoader;
XSLoader::load('Bloom::Faster', $VERSION);


sub new {
    my ($package,$data)  = @_;
    my %struct;
    if (! (ref $data)) {
	$struct{vector} = bdeserialize($data);
    } else {
	if (defined($data->{e}) && defined($data->{n})) {
	    $struct{vector} = binit_sugg($data->{n},$data->{e});
	} elsif (defined($data->{m}) && defined($data->{k})) {
			$data->{n} = $data->{e} = 0;
	    $struct{vector} = binit($data->{m},$data->{k},$data->{n},$data->{e});
	} else {
	    $! = "invalid arguments to Bloom::Faster";
	    return undef;
	}

	if (!defined($struct{vector})) {
	    $! = "bloom init failure\n";
	    return undef;
	}
    }
    # binit will implicitly set m to a close prime
    ###$struct{inserts} = 0;

    bless \%struct => $package;
}

sub from_file {
    my ($self, $filename) = @_;
    bloom_destroyer($self->{vector});
    $self->{vector} = bdeserialize($filename);
}

sub to_file {
    my ($self, $filename) = @_;
    return bserialize($self->{vector}, $filename);

}

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

    return get_vector($self->{vector});
}

sub get_suggestion {
    my ($n,$e) = @_;

    my ($m,$k);
    $m = $k = 0;

    suggestion($n,$e,$m,$k);

    return ($m,$k);
}

sub DESTROY {
    my ($self) = @_;
    defined($self->{vector}) and bloom_destroyer($self->{vector});
}

sub get_inserts {
    my ($self) = @_;
    ##return $self->{inserts};
    return binserts($self->{vector});
}

sub key_count {
    my ($self) = @_;
    return $self->get_inserts();
}

sub capacity {
    my ($self) = @_;
    return bcapacity($self->{vector});
}

sub get_vectorsize {
    my ($self) = @_;
    return belements($self->{vector});
}

sub test {
    my ($self,$str) = @_;

    return $self->add($str);
}

sub check {
    my ($self,$str) = @_;

    ##$self->{inserts}++;
    return test_bloom($self->{vector},$str,0);
}

sub add {
    my ($self,$str) = @_;

    ##$self->{inserts}++;
    return test_bloom($self->{vector},$str,1);
}



# Preloaded methods go here.

# Autoload methods go after =cut, and are processed by the autosplit program.

1;
__END__