File Coverage

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

Criterion	Covered	Total	%
statement	130	130	100.0
branch	43	50	86.0
condition	12	15	80.0
subroutine	41	41	100.0
pod	20	20	100.0
total	246	256	96.0

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_VERSION  => 2;  # PDS space result set object or undef
use constant _F_PATH     => 3;  # database path name
use constant _NFIELDS    => 4;

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

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

use constant _KNOWN => { '<>' => 0 };

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

sub _iterate {
    my ($domain, $query, $min, $max, @columns) = @_;
    my @sel  = $query? @{$query}: ();
    my @osel = ();
    my $dir = 'ASC';
    if (defined($min) && defined($max) && $min > $max) {
        ($min, $max, $dir) = ($max, $min, 'DESC');
    }
    push @osel, '>=' => $min if defined $min;
    push @osel, '<=' => $max if defined $max;
    push @sel, order_ => { @osel } if @osel;
    my $results = $domain->search(
        @sel? { @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 _version { $_[0]->[_F_VERSION] }
sub _path    { $_[0]->[_F_PATH]    }

sub _get_version_of {
    my ($this, $table_name) = @_;
    my $version = $this->_version;
    return (0, 0) if !defined $version;
    my $rec = $version->search({ table_name => $table_name })->single;
    return (0, 0) if !defined $rec;
    return ($rec->major, $rec->minor);
}

# ----- 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 };
    my $version = $schema->resultset('DatabaseVersion');
    undef $version if !eval { $version->search->count };
    return bless [$data, $spaces, $version, $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 get_version       { $_[0]->_get_version_of('difference_set')       }
sub get_space_version { $_[0]->_get_version_of('difference_set_space') }

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

sub iterate_properties {
    my ($this, $min, $max, @columns) = @_;
    foreach my $col (@columns) {
        $col = 'order_' if $col eq 'order';
    }
    @columns =
        grep {!/delta/}
        Math::DifferenceSet::Planar::Schema::Result::DifferenceSet->columns
        if !@columns;
    return _iterate($this->_data, undef, $min, $max, @columns);
}

sub iterate_refs {
    my ($this, $type, $min, $max) = @_;
    return _iterate($this->_data, [$type => { '<>' => 0 }], $min, $max);
}

sub iterate_spaces {
    my ($this, $min, $max) = @_;
    my $spaces = $this->_spaces;
    return sub {} if !defined $spaces;
    return _iterate($spaces, undef, $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 $spaces && $spaces->get_column('order_')->min;
}

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

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

sub ref_min_order {
    my ($this, $type) = @_;
    return $this->_data->search({$type => _KNOWN})->get_column('order_')->min;
}

sub ref_max_order {
    my ($this, $type) = @_;
    return $this->_data->search({$type => _KNOWN})->get_column('order_')->max;
}

sub ref_count {
    my ($this, $type) = @_;
    return $this->_data->search({$type => _KNOWN})->count;
}

1;

__END__