File Coverage

blib/lib/Text/KDL/XS/Value.pm

Criterion	Covered	Total	%
statement	23	34	67.6
branch	8	26	30.7
condition	0	3	0.0
subroutine	10	15	66.6
pod	11	12	91.6
total	52	90	57.7

package Text::KDL::XS::Value;

use strict;
use warnings;

use Carp ();

# A Value is a blessed hashref with these slots:
#   type            : 'null' | 'bool' | 'number' | 'string'
#   kind            : 'integer' | 'float' | 'string'   (only when type=number)
#   value           : underlying scalar (IV/NV/PV) or undef
#   type_annotation : string, optional KDL type tag like "u32"

sub new {
    my ($class, %args) = @_;
    Carp::croak("Text::KDL::XS::Value->new: 'type' is required")
        unless defined $args{type};

    return bless {
        type            => $args{type},
        kind            => $args{kind},
        value           => $args{value},
        type_annotation => $args{type_annotation},
    }, $class;
}

sub type            { $_[0]->{type}            }
sub kind            { $_[0]->{kind}            }
sub type_annotation { $_[0]->{type_annotation} }

sub is_null   { $_[0]->{type} eq 'null'   }
sub is_bool   { $_[0]->{type} eq 'bool'   }
sub is_number { $_[0]->{type} eq 'number' }
sub is_string { $_[0]->{type} eq 'string' }

# Raw underlying scalar (already typed in XS).
sub value { $_[0]->{value} }

# Returns a Perl number suitable for arithmetic when possible.
# Arbitrary-precision integers are still returned as strings; callers
# who need bigint semantics should pass C to Math::BigInt.
sub as_number {
    my ($self) = @_;
    return undef if $self->{type} eq 'null';
    return $self->{type} eq 'bool' ? ($self->{value} ? 1 : 0) : $self->{value} + 0
        if $self->{type} ne 'number';
    return $self->{value} if defined $self->{kind} && $self->{kind} ne 'string';
    # string-encoded number - preserve as string-on-the-wire but coerce at use
    return $self->{value};
}

sub as_string {
    my ($self) = @_;
    return undef        if $self->{type} eq 'null';
    return $self->{value} ? 'true' : 'false' if $self->{type} eq 'bool';
    return defined $self->{value} ? "$self->{value}" : undef;
}

# Best-effort native Perl scalar:
#   null    -> undef
#   bool    -> 1/0
#   number  -> IV / NV / string (for arbitrary-precision)
#   string  -> PV
sub as_perl {
    my ($self) = @_;
    my $t = $self->{type};
    return undef           if $t eq 'null';
    return $self->{value} ? 1 : 0 if $t eq 'bool';
    return $self->{value};
}

1;

__END__