File Coverage

blib/lib/Data/Types.pm

Criterion	Covered	Total	%
statement	50	50	100.0
branch	47	48	97.9
condition	27	28	96.4
subroutine	15	15	100.0
pod	12	12	100.0
total	151	153	98.6

package Data::Types;

use strict;
require Exporter;
use vars qw($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);

$VERSION = '0.15';

@ISA = qw(Exporter);

@EXPORT_OK = qw(is_whole to_whole is_count to_count is_int to_int is_real
                to_real is_decimal to_decimal is_float to_float is_string
                to_string );

@EXPORT = qw();

%EXPORT_TAGS = (
    all     => \@EXPORT_OK,
    whole   => [qw(is_whole to_whole)],
    count   => [qw(is_count to_count)],
    int     => [qw(is_int to_int)],
    decimal => [qw(is_decimal to_decimal)],
    real    => [qw(is_real to_real)],
    float   => [qw(is_float to_float)],
    string  => [qw(is_string to_string)],
    is      => [qw(is_whole is_int is_real is_decimal is_float is_string)],
    to      => [qw(to_whole to_int to_real to_decimal to_float to_string)],
);

use constant DEF_PRECISION => 5;

################################################################################
# FUNCTIONS                                                                    #
################################################################################

sub is_whole ($) {
    return unless defined $_[0];
    return unless $_[0] =~ /^[0-9]+$/;
    return 1;
}

sub to_whole ($) {
    return unless defined $_[0];
    my ($num) = $_[0] =~ /([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+))/;
    return unless defined $num && $num >= 0;
    sprintf "%.0f", $num;
}

sub is_count ($) {
    return unless $_[0];
    return unless $_[0] =~ /^[0-9]+$/;
    return 1;
}

sub to_count ($) {
    return unless $_[0];
    my ($num) = $_[0] =~ /([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+))/;
    return unless $num && $num > .5;
    sprintf "%.0f", $num;
}

sub is_int ($) {
    return unless defined $_[0] && $_[0] ne '';
    return unless $_[0] =~ /^[+-]?[0-9]+$/;
    return 1;
}

sub to_int ($) {
    return unless defined $_[0] && $_[0] ne '';
    my ($num) = $_[0] =~ /([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+))/;
    return unless defined $num;
    sprintf "%.0f", $num;
}

sub is_decimal ($) {
    return unless defined $_[0] && $_[0] ne '';
    return unless $_[0] =~ /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/;
    return 1;
}

sub to_decimal ($;$) {
    return unless defined $_[0] && $_[0] ne '';
    my ($num) = $_[0] =~ /([+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+))/;
    return unless defined $num;
    $_[1] ||= DEF_PRECISION;
    sprintf "%.$_[1]f", $num;
}

#sub is_real ($) {
#    return unless defined $_[0] && $_[0] ne '';
#    return unless $_[0] =~ /^[+-]?\d*\.?\d*$/;
#    return 1;
#}

#sub to_real ($) {
#    return unless defined $_[0] && $_[0] ne '';
#    sprintf "%f", $_[0] =~ /([+-]?\d*\.?\d*)/;
#}

# These may need to be separated in the future, in order to identify non-decimal
# real numbers.
*is_real = *is_decimal;
*to_real = *to_decimal;

sub is_float ($) {
    return unless defined $_[0] && $_[0] ne '';
    return unless $_[0] =~ /^([+-]?)(?=[0-9]|\.[0-9])[0-9]*(\.[0-9]*)?([Ee]([+-]?[0-9]+))?$/;
    return 1;
}

sub to_float ($;$) {
    return unless defined $_[0] && $_[0] ne '';
    my ($num) = $_[0] =~ /(([+-]?)(?=[0-9]|\.[0-9])[0-9]*(\.[0-9]*)?([Ee]([+-]?[0-9]+))?)/;
    return unless defined $num;
    my $type = $num =~ /e|E/ ? 'e' : 'f';
    $_[1] ||= DEF_PRECISION;
    sprintf "%.$_[1]$type", $num;
#    sprintf "%g", $_[0] =~ /(([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)/;
}

sub is_string ($) { defined $_[0] && ! ref $_[0] }

sub to_string ($;$) {
    return unless defined $_[0];
    return $_[1] ? substr("$_[0]", 0, $_[1]) : "$_[0]";
}

1;
__END__