Guillaume Aubert > Data-Validate-Type-1.4.0 > Data::Validate::Type

Download:
Data-Validate-Type-1.4.0.tar.gz

Dependencies

Annotate this POD

Website

View/Report Bugs
Module Version: v1.4.0   Source   Latest Release: Data-Validate-Type-v1.5.1

NAME ^

Data::Validate::Type - Data type validation functions.

VERSION ^

Version 1.4.0

SYNOPSIS ^

        # Call with explicit package name.
        use Data::Validate::Type;
        if ( Data::Validate::Type::is_string( 'test' ) )
        {
                # ...
        }

        # Import specific functions.
        use Data::Validate::Type qw( is_string );
        if ( is_string( 'test' ) )
        {
                # ...
        }

        # Import functions for a given paradigm.
        use Data::Validate::Type qw( :boolean_tests );
        if ( is_string( 'test' ) )
        {
                # ...
        }

DESCRIPTION ^

Params::Util is a wonderful module, but suffers from a few drawbacks:

Those drawbacks are purely cosmetic and don't affect the usefulness of the functions, except for the last one. This module used to encapsulate Params::Util, but I had to refactor it out to fix the issues with Devel::Cover.

Please note that I prefer long function names that are descriptive, to arcane short ones. This increases readability, and the bulk of the typing can be spared with the use of a good IDE like Padre.

Also, this is work in progress - There is more functions that should be added here, if you need one in particular feel free to contact me.

BOOLEAN TEST FUNCTIONS ^

Functions in this group return a boolean to indicate whether the parameters passed match the test(s) specified by the functions or not.

All the boolean functions can be imported at once in your namespace with the following line:

        use Data::Validate::Type qw( :boolean_tests );

is_string()

Return a boolean indicating if the variable passed is a string.

        my $is_string = Data::Validate::Type::is_string( $variable );

Note: 0 and '' (empty string) are valid strings.

Parameters:

is_arrayref()

Return a boolean indicating if the variable passed is an arrayref that can be dereferenced into an array.

        my $is_arrayref = Data::Validate::Type::is_arrayref( $variable );
        
        my $is_arrayref = Data::Validate::Type::is_arrayref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );
        
        # Check if the variable is an arrayref of hashrefs.
        my $is_arrayref = Data::Validate::Type::is_arrayref(
                $variable,
                allow_empty           => 1,
                no_blessing           => 0,
                element_validate_type =>
                        sub
                        {
                                return Data::Validate::Type::is_hashref( $_[0] );
                        },
        );

Parameters:

is_hashref()

Return a boolean indicating if the variable passed is a hashref that can be dereferenced into a hash.

        my $is_hashref = Data::Validate::Type::is_hashref( $variable );
        
        my $is_hashref = Data::Validate::Type::is_hashref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );

Parameters:

is_coderef()

Return a boolean indicating if the variable passed is an coderef that can be dereferenced into a block of code.

        my $is_coderef = Data::Validate::Type::is_coderef( $variable );

is_number()

Return a boolean indicating if the variable passed is a number.

        my $is_number = Data::Validate::Type::is_number( $variable );
        my $is_number = Data::Validate::Type::is_number(
                $variable,
                positive => 1,
        );
        my $is_number = Data::Validate::Type::is_number(
                $variable,
                strictly_positive => 1,
        );

Parameters:

is_instance()

Return a boolean indicating if the variable is an instance of the given class.

Note that this handles inheritance properly, so it will return true if the variable is an instance of a subclass of the class given.

        my $is_instance = Data::Validate::Type::is_instance(
                $variable,
                class => $class,
        );

Parameters:

ASSERTION-BASED FUNCTIONS ^

Functions in this group do not return anything, but will die when the parameters passed don't match the test(s) specified by the functions.

All the assertion test functions can be imported at once in your namespace with the following line:

        use Data::Validate::Type qw( :assertions );

assert_string()

Die unless the variable passed is a string.

        Data::Validate::Type::assert_string( $variable );

Note: 0 and '' (empty string) are valid strings.

Parameters:

assert_arrayref()

Die unless the variable passed is an arrayref that can be dereferenced into an array.

        Data::Validate::Type::assert_arrayref( $variable );
        
        Data::Validate::Type::assert_arrayref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );
        
        # Require the variable to be an arrayref of hashrefs.
        Data::Validate::Type::assert_arrayref(
                $variable,
                allow_empty           => 1,
                no_blessing           => 0,
                element_validate_type =>
                        sub
                        {
                                return Data::Validate::Type::is_hashref( $_[0] );
                        },
        );

Parameters:

assert_hashref()

Die unless the variable passed is a hashref that can be dereferenced into a hash.

        Data::Validate::Type::assert_hashref( $variable );
        
        Data::Validate::Type::assert_hashref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );

Parameters:

assert_coderef()

Die unless the variable passed is an coderef that can be dereferenced into a block of code.

        Data::Validate::Type::assert_coderef( $variable );

assert_number()

Die unless the variable passed is a number.

        Data::Validate::Type::assert_number( $variable );
        Data::Validate::Type::assert_number(
                $variable,
                positive => 1,
        );
        Data::Validate::Type::assert_number(
                $variable,
                strictly_positive => 1,
        );

Parameters:

assert_instance()

Die unless the variable is an instance of the given class.

Note that this handles inheritance properly, so it will not die if the variable is an instance of a subclass of the class given.

        Data::Validate::Type::assert_instance(
                $variable,
                class => $class,
        );

Parameters:

FILTERING FUNCTIONS ^

Functions in this group return the variable tested against when it matches the test(s) specified by the functions.

All the filtering functions can be imported at once in your namespace with the following line:

        use Data::Validate::Type qw( :filters );

filter_string()

Return the variable passed if it is a string, otherwise return undef.

        Data::Validate::Type::filter_string( $variable );

Note: 0 and '' (empty string) are valid strings.

Parameters:

filter_arrayref()

Return the variable passed if it is an arrayref that can be dereferenced into an array, otherwise undef.

        Data::Validate::Type::filter_arrayref( $variable );
        
        Data::Validate::Type::filter_arrayref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );
        
        # Only return the variable if it is an arrayref of hashrefs.
        Data::Validate::Type::filter_arrayref(
                $variable,
                allow_empty           => 1,
                no_blessing           => 0,
                element_validate_type =>
                        sub
                        {
                                return Data::Validate::Type::is_hashref( $_[0] );
                        },
        );

Parameters:

filter_hashref()

Return the variable passed if it is a hashref that can be dereferenced into a hash, otherwise return undef.

        Data::Validate::Type::filter_hashref( $variable );
        
        Data::Validate::Type::filter_hashref(
                $variable,
                allow_empty => 1,
                no_blessing => 0,
        );

Parameters:

filter_coderef()

REturn the variable passed if it is a coderef that can be dereferenced into a block of code, otherwise return undef.

        Data::Validate::Type::filter_coderef( $variable );

filter_number()

Return the variable passed if it is a number, otherwise return undef.

        Data::Validate::Type::filter_number( $variable );
        Data::Validate::Type::filter_number(
                $variable,
                positive => 1,
        );
        Data::Validate::Type::filter_number(
                $variable,
                strictly_positive => 1,
        );

Parameters:

filter_instance()

Return the variable passed if it is an instance of the given class.

Note that this handles inheritance properly, so it will return the variable if it is an instance of a subclass of the class given.

        Data::Validate::Type::filter_instance(
                $variable,
                class => $class,
        );

Parameters:

AUTHOR ^

Guillaume Aubert, <aubertg at cpan.org>.

BUGS ^

Please report any bugs or feature requests to bug-data-validate-type at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Data-Validate-Type. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

SUPPORT ^

You can find documentation for this module with the perldoc command.

        perldoc Data::Validate::Type

You can also look for information at:

ACKNOWLEDGEMENTS ^

Thanks to Adam Kennedy for writing Params::Util. This module started as an encapsulation for Params::Util and I learnt quite a bit from it.

COPYRIGHT & LICENSE ^

Copyright 2012 Guillaume Aubert.

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/

syntax highlighting: