File Coverage

blib/lib/Games/Solitaire/Verify/Freecells.pm

Criterion	Covered	Total	%
statement	60	63	95.2
branch	15	18	83.3
condition			n/a
subroutine	16	16	100.0
pod	8	8	100.0
total	99	105	94.2

package Games::Solitaire::Verify::Freecells;
$Games::Solitaire::Verify::Freecells::VERSION = '0.2402';
use warnings;
use strict;


use parent 'Games::Solitaire::Verify::Base';

use Games::Solitaire::Verify::Exception ();
use Games::Solitaire::Verify::Card      ();

# _s is the string.
__PACKAGE__->mk_acc_ref(
    [
        qw(
            _count
            _cells
            _s
            )
    ]
);


sub _input_from_string
{
    my $self = shift;
    my $str  = shift;

    if ( $str !~ m{\AFreecells:}gms )
    {
        Games::Solitaire::Verify::Exception::Parse::State::Freecells->throw(
            error => "Wrong Freecell String", );
    }

POS:
    for my $pos ( 0 .. ( $self->count() - 1 ) )
    {
        if ( $str =~ m{\G\z}cg )
        {
            last POS;
        }
        elsif ( $str =~ m{\G  (..)}gms )
        {
            my $card_s = $1;
            $self->assign( $pos, $self->_parse_freecell_card($card_s) );
        }
        else
        {
            Games::Solitaire::Verify::Exception::Parse::State::Freecells
                ->throw( error => "Wrong Freecell String", );
        }
    }
}

sub _init
{
    my ( $self, $args ) = @_;

    if ( !exists( $args->{count} ) )
    {
        die "The count was not specified for the freecells";
    }

    $self->_count( $args->{count} );

    $self->_s( 'Freecells:' . ( '    ' x $self->_count ) );

    $self->_cells( [ (undef) x $self->_count() ] );

    if ( exists( $args->{string} ) )
    {
        return $self->_input_from_string( $args->{string} );
    }

    return;
}

sub _parse_freecell_card
{
    my ( $self, $s ) = @_;

    return (
        ( $s eq q{  } )
        ? undef()
        : Games::Solitaire::Verify::Card->new(
            {
                string => $s,
            }
        )
    );
}


sub count
{
    my $self = shift;

    return $self->_count();
}


sub cell
{
    my ( $self, $idx ) = @_;

    return $self->_cells()->[$idx];
}


sub assign
{
    my ( $self, $idx, $card ) = @_;

    $self->_cells()->[$idx] = $card;
    substr(
        $self->{_s}, length('Freecells:') + ( $idx << 2 ) + 2,
        2, ( defined($card) ? $card->fast_s : '  ' )
    );

    return;
}


sub to_string
{
    ( my $r = $_[0]->{_s} ) =~ s# +\z##;
    return $r;
}


sub cell_clone
{
    my ( $self, $pos ) = @_;

    my $card = $self->cell($pos);

    return defined($card) ? $card->clone() : undef();
}


sub clear
{
    my ( $self, $pos ) = @_;

    $self->assign( $pos, undef() );

    return;
}


sub clone
{
    my $self = shift;

    my $copy = __PACKAGE__->new(
        {
            count => $self->count(),
        }
    );

    foreach my $pos ( 0 .. ( $self->count() - 1 ) )
    {
        $copy->assign( $pos, $self->cell_clone($pos) );
    }

    return $copy;
}


sub num_empty
{
    my $self = shift;

    my $count = 0;

    foreach my $fc_idx ( 0 .. ( $self->count() - 1 ) )
    {
        if ( !defined( $self->cell($fc_idx) ) )
        {
            ++$count;
        }
    }
    return $count;
}

1;    # End of Games::Solitaire::Verify::Freecells

__END__