File Coverage

blib/lib/Time/List/Rows.pm

Criterion	Covered	Total	%
statement	89	126	70.6
branch	16	26	61.5
condition	7	15	46.6
subroutine	12	18	66.6
pod	8	10	80.0
total	132	195	67.6

package Time::List::Rows;
use 5.008_001;
use strict;
use warnings;
use Time::Piece;
use Class::Accessor::Lite;
use Time::List::Rows::Row;
use Time::List::Constant;

our $VERSION = '0.12';

my $unit_time = {
    DAY()   => 3600 * 24 ,
    WEEK()  => 3600 * 24 * 7 ,
    HOUR()  => 3600 ,
};

my %DEFAULTS = (
    time_unit       => DAY() ,
    output_type     => ARRAY() ,
    limit_rows      => 0 ,
    input_strftime_form    => '%Y-%m-%d %H:%M:%S',
    output_strftime_form   => '%Y-%m-%d %H:%M:%S',
    show_end_time   => 0 ,
    end_time_separate_chars   => '~' ,
    time_array => [],
    time_rows => [],
    unixtime_rows_hash => {},
    datetime_rows_hash => {},
    create_summary => 0 ,
    summary_key_name => "summary" ,
    filter => undef ,
    filter_keys => [] ,
);

Class::Accessor::Lite->mk_accessors(keys %DEFAULTS);

sub new {
    my $class = shift;

    my %args = @_ == 1 ? %{ $_[0] } : @_;
    my $self = bless {
        %DEFAULTS,
        %args,
    }, $class;

    die "set time array" unless $self->time_array;
    $self->_create_time_rows(\%args);
    $self;
}

sub _create_time_rows{
    my ($self , $args)  = @_;
    my $time_array = $self->time_array;
    my $time_rows = [map{
        Time::List::Rows::Row->new(%$args , unixtime => $_);
    }@$time_array];
    my $unixtime_rows_hash = {map{
        $_->unixtime => $_,
    }@$time_rows};
    my $datetime_rows_hash = {map{
        $_->datetime => $_,
    }@$time_rows};
    $self->time_rows($time_rows);
    $self->unixtime_rows_hash($unixtime_rows_hash);
    $self->datetime_rows_hash($datetime_rows_hash);
}

sub get_row_from_datetime{
    my ($self , $datetime)  = @_;
    $self->unixtime_rows_hash()->{$datetime};
}

sub get_row_from_unixtime{
    my ($self , $unixtime)  = @_;
    $self->unixtime_rows_hash()->{$unixtime};
}

sub set_row_from_datetime{
    my ($self , $datetime , $values)  = @_;
    $self->unixtime_rows_hash()->{$datetime}->set($values);
}

sub set_row_from_unixtime{
    my ($self , $unixtime , $values)  = @_;
    $self->unixtime_rows_hash()->{$unixtime}->set($values);
}

sub set_rows_from_input_strftime{
    my ($self , $rows)  = @_;
    my $strf_form = $self->input_strftime_form;
    my $keys = {};
    for my $time(keys %$rows){
        my $values = $rows->{$time};
        for(keys %$values){
            $keys->{$_} = 1;
        }
        my $unixtime = Time::Piece->strptime($time , $strf_form)->strftime('%s');
        my $row = $self->unixtime_rows_hash()->{$unixtime};
        $row->set($values) if $row;
    }
    my $time_rows = $self->time_rows();
    for(@$time_rows){
        $_->{$keys} ||= undef;
    }
}

sub set_rows_from_datetime{
    my ($self , $rows)  = @_;
    my $keys = {};
    for my $datetime(keys %$rows){
        my $values = $rows->{$datetime};
        for(keys %$values){
            $keys->{$_} = 1;
        }
        my $row = $self->datetime_rows_hash()->{$datetime};
        $row->set($values) if $row;
    }
    my $time_rows = $self->time_rows();
    for(@$time_rows){
        $_->{$keys} ||= undef;
    }
}

sub set_rows_from_unixtime{
    my ($self , $rows)  = @_;
    my $keys = {};
    for my $unixtime(keys %$rows){
        my $values = $rows->{$unixtime};
        for(keys %$values){
            $keys->{$_} = 1;
        }
        my $row = $self->unixtime_rows_hash()->{$unixtime};
        $row->set($values) if $row;
    }
    my $time_rows = $self->time_rows();
    for(@$time_rows){
        $_->{$keys} ||= undef;
    }
}

sub get_array{
    my ($self)  = @_;
    my $unixtime_rows_hash = $self->unixtime_rows_hash;
    if($self->create_summary){
        my $summary = {};

        my $rows = [map{
            my $row = $unixtime_rows_hash->{$_->unixtime}->get_values;
            if($self->filter){
                $row = {%$row};
                my @filter_keys = @{$self->filter_keys};
                if(ref $filter_keys[0] eq "SCALAR" && ${$filter_keys[0]} eq "*"){
                    @filter_keys = keys $row
                }
                for my $key (@filter_keys){
                    if(exists $row->{$key}){
                        $row->{$key} = $self->filter->($row->{$key});
                    }
                }
            }

            for my $key(keys %$row){
                my $value = $row->{$key};
                if($value && $value =~ /(^|^-)(\d+|\d+\.\d+)$/){
                    $summary->{$key} += $value;
                }
            }

            $row;
        }@{$self->time_rows}];
        $summary->{output_time} = $self->summary_key_name;
        push @$rows , $summary ;
        unshift @$rows , $summary;

        return $rows;
    }else{
        return [map{
                my $row = $unixtime_rows_hash->{$_->unixtime}->get_values;

                if($self->filter){
                    $row = {%$row};
                    my @filter_keys = @{$self->filter_keys};
                    if(ref $filter_keys[0] eq "SCALAR" && ${$filter_keys[0]} eq "*"){
                        @filter_keys = keys $row
                    }
                    for my $key (@filter_keys){
                        if(exists $row->{$key}){
                            $row->{$key} = $self->filter->($row->{$key});
                        }
                    }
                }

                $row;
            }@{$self->time_rows}]
    }
}

sub get_hash{
    my ($self)  = @_;
    return {map{$_->get_hash_seed}@{$self->time_rows}};
}

1;


1;
__END__