File Coverage

blib/lib/InfluxDB/Client/DataSet.pm

Criterion	Covered	Total	%
statement	41	68	60.2
branch	8	28	28.5
condition	8	24	33.3
subroutine	9	15	60.0
pod	8	8	100.0
total	74	143	51.7

package InfluxDB::Client::DataSet;
# ABSTRACT: simple container to hold and prepare data for Cwrite()>


use strict;
use warnings;

use Carp;
use Time::HiRes;
use InfluxDB::LineProtocol;

our $VERSION = '0.1';

sub new {
    my ($class, %args );
    # check if we have only one argument
    if ( @_ == 2 ) {
        my $measurement;
        ( $class, $measurement ) = @_;
        $args{measurement} = $measurement;
    } else {
        # else we assume we got an hash
        ( $class, %args ) = @_;
    }

    # check the precision
    $args{precision} //= 'ns';

    # set our timestamp function
    my $get_ts;
    {
        ## no critic qw(TestingAndDebugging::ProhibitNoStrict)
        no strict 'refs';
        my $ts_func = 'InfluxDB::LineProtocol::ts_' . $args{precision};
        *{"$class\::get_ts"} = \&$ts_func;
    }

    # set the timestamp
    $args{timestamp} //= $class->get_ts();

    # validate the measurement parameter
    croak 'no measurement given'
        unless defined  $args{measurement};
    croak 'measurement must not be a reference'
        if ( ref $args{measurement} );

    # validate the values parameters
    if (exists $args{values} && defined $args{values}) {
        croak 'values must be a hash reference'
            unless (ref $args{values} && ref $args{values} eq 'HASH');
    }

    # validate the tags parameters
    if (exists $args{tags} && defined $args{tags}) {
        croak 'values must be a hash reference'
            unless (ref $args{tags} && ref $args{tags} eq 'HASH');
    }

    # construct $self
    my $self = bless {
        _measurement => $args{measurement},
        _values      => $args{values} // {},
        _tags        => $args{tags} // {},
        _precision   => $args{precision},
        _ts          => $args{timestamp}
    } => $class;
    return $self;
}


sub measurement {
    my ( $self, $m ) = @_;
    if ( $m ) {
        croak 'measurement must not be a reference'
            if ( ref $m );
        $self->{_measurement} = $m;
    }
    return $self->{_measurement};
}


sub value {
    $_[0]->_set_tag_or_values('values',@_);
}

sub tag {
    $_[0]->_set_tag_or_values('tags',@_);
}

sub precision {
    return $_[0]->{_precision};
}

sub ts {
    my ( $self, $ts ) = @_;
    $self->{_ts} = $ts if $ts;
    return $self->{_ts};
}

sub set_ts {
    my ( $self, $ts ) = @_;
    $self->ts($ts // $self->get_ts);
}



sub as_string {
    my ( $self ) = @_;
    return InfluxDB::LineProtocol::data2line($self->{_measurement}, $self->{_values}, $self->{_tags}, $self->{_ts});
}

# helper for the tag() and value() functions
sub _set_tag_or_values {
    my $self = shift;
    my $elem = shift;
    # check if we have a single paramter
    if ( @_ == 1 ) {
        my ($p) = @_;
        # if the paramter is a hasreference, we override our internal storage
        if (ref $p ) {
            croak "either a $elem key or a hash reference wanted"
                unless (ref $p eq 'HASH');
            # copy the hash reference
            $self->{'_'.$elem} = { %$p };
        } else {
            # we just fetch the element and return it
            return $self->{'_'.$elem}{$p} if ( exists $self->{'_'.$elem}{$p} );
            # return undef if the key does not exist
            return;
        }
    } else {
        my ( %pairs ) = @_;
        foreach my $k ( keys %pairs ) {
            $self->{'_'.$elem}{$k} = $pairs{$k};
        }
    }
    # we return a copy of our internal storage
    return { %{$self->{'_'.$elem}} }
}

1;

__END__