File Coverage

blib/lib/Math/DifferenceSet/Planar/Data.pm

Criterion	Covered	Total	%
statement	100	100	100.0
branch	36	40	90.0
condition	8	9	88.8
subroutine	31	31	100.0
pod	14	14	100.0
total	189	194	97.4

package Math::DifferenceSet::Planar::Data;

use strict;
use warnings;
use Carp qw(croak);
use File::Spec;
use File::Share qw(dist_dir);
use DBD::SQLite::Constants qw(SQLITE_OPEN_READONLY);
use Math::DifferenceSet::Planar::Schema;

# Math::DifferenceSet::Planar::Data=ARRAY(...)

# .......... index ..........   # .......... value ..........
use constant _F_DATA     => 0;  # difference set result set object
use constant _F_SPACES   => 1;  # PDS space result set object or undef
use constant _F_PATH     => 2;  # database path name
use constant _NFIELDS    => 3;

our $VERSION  = '0.018';
our @CARP_NOT = qw(Math::DifferenceSet::Planar);

our $DATABASE_DIR = dist_dir('Math-DifferenceSet-Planar');

# ----- private subroutines -----

sub _iterate {
    my ($domain, $min, $max, @columns) = @_;
    my @sel = ();
    my $dir = 'ASC';
    if (defined($min) && defined($max) && $min > $max) {
        ($min, $max, $dir) = ($max, $min, 'DESC');
    }
    push @sel, '>=' => $min if defined $min;
    push @sel, '<=' => $max if defined $max;
    my $results = $domain->search(
        @sel? { order_ => { @sel } }: undef,
        {
            @columns? ( columns => \@columns ): (),
            order_by => "order_ $dir",
        }
    );
    return sub { $results->next };
}

# ----- private accessor methods -----

sub _data   { $_[0]->[_F_DATA]   }
sub _spaces { $_[0]->[_F_SPACES] }
sub _path   { $_[0]->[_F_PATH]   }

# ----- class methods -----

sub list_databases {
    opendir my $dh, $DATABASE_DIR or return ();
    my @files =
        map {
            my $is_standard = /^pds[_\W]/i? 1: 0;
            my $path = File::Spec->rel2abs($_, $DATABASE_DIR);
            (-f $path)? [$_, $is_standard, -s _]: ()
        }
        grep { /\.db\z/i } readdir $dh;
    closedir $dh;
    return
        map { $_->[0] }
        sort {
            $b->[1] <=> $a->[1] || $b->[2] <=> $a->[2] ||
            $a->[0] cmp $b->[0]
        }
        @files;
}

sub new {
    my $class = shift;
    my ($filename) = @_? @_: $class->list_databases
        or croak "bad database: empty share directory: $DATABASE_DIR";
    my $path = File::Spec->rel2abs($filename, $DATABASE_DIR);
    -e $path or croak "bad database: file does not exist: $path";
    my $schema =
        Math::DifferenceSet::Planar::Schema->connect(
            "dbi:SQLite:$path", q[], q[],
            { sqlite_open_flags => SQLITE_OPEN_READONLY },
        );
    my $data = $schema->resultset('DifferenceSet');
    my $count = eval { $data->search->count };
    croak "bad database: query failed: $@" if !defined $count;
    my $spaces = $schema->resultset('DifferenceSetSpace');
    undef $spaces if !eval { $spaces->search->count };
    return bless [$data, $spaces, $path], $class;
}

# ----- object methods -----

sub get {
    my ($this, $order, @columns) = @_;
    return $this->_data->search(
        { order_ => $order },
        @columns ? { columns => \@columns } : ()
    )->single;
}

sub get_space {
    my ($this, $order) = @_;
    my $spaces = $this->_spaces;
    return undef if !defined $spaces;
    return $spaces->search({ order_ => $order })->single;
}

sub iterate {
    my ($this, $min, $max) = @_;
    return _iterate($this->_data, $min, $max);
}

sub iterate_properties {
    my ($this, $min, $max) = @_;
    my @columns = qw(order_ base exponent modulus n_planes);
    return _iterate($this->_data, $min, $max, @columns);
}

sub iterate_spaces {
    my ($this, $min, $max) = @_;
    my $spaces = $this->_spaces;
    return sub {} if !defined $spaces;
    return _iterate($spaces, $min, $max);
}

sub min_order    { $_[0]->_data->get_column('order_')->min  }
sub max_order    { $_[0]->_data->get_column('order_')->max  }
sub count        { $_[0]->_data->search->count              }
sub path         { $_[0]->_path                             }

sub sp_min_order {
    my ($this) = @_;
    my $spaces = $this->_spaces;
    return undef if !defined $spaces;
    return $spaces->get_column('order_')->min;
}

sub sp_max_order {
    my ($this) = @_;
    my $spaces = $this->_spaces;
    return 0 if !defined $spaces;
    return $spaces->get_column('order_')->max;
}

sub sp_count {
    my ($this) = @_;
    my $spaces = $this->_spaces;
    return 0 if !defined $spaces;
    return $spaces->search->count;
}

1;

__END__