GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  DATA::OBJECT::LIBRARY (3)

.ds Aq ’

NAME

Data::Object::Library - Type Library for Perl 5

CONTENTS

VERSION

version 0.59

SYNOPSIS



    use Data::Object::Library;



DESCRIPTION

Data::Object::Library is a Type::Tiny type library that extends the Types::Standard, Types::Common::Numeric, and Types::Common::String libraries and adds type constraints and coercions for Data::Object objects.

TYPES

    Any



    has data => (
        is  => rw,
        isa => Any,
    );



The Any type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Any function can be used to throw an exception is the argument can not be validated. The is_Any function can be used to return true or false if the argument can not be validated.

    AnyObj



    has data => (
        is  => rw,
        isa => AnyObj,
    );



The AnyObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Universal object. The assert_AnyObj function can be used to throw an exception if the argument can not be validated. The is_AnyObj function can be used to return true or false if the argument can not be validated.

    AnyObject



    has data => (
        is  => rw,
        isa => AnyObject,
    );



The AnyObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Universal object. The assert_AnyObject function can be used to throw an exception if the argument can not be validated. The is_AnyObject function can be used to return true or false if the argument can not be validated.

    ArrayObj



    has data => (
        is  => rw,
        isa => ArrayObj,
    );



The ArrayObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObj function can be used to throw an exception if the argument can not be validated. The is_ArrayObj function can be used to return true or false if the argument can not be validated.

    ArrayObject



    has data => (
        is  => rw,
        isa => ArrayObject,
    );



The ArrayObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObject function can be used to throw an exception if the argument can not be validated. The is_ArrayObject function can be used to return true or false if the argument can not be validated.

    ArrayRef



    has data => (
        is  => rw,
        isa => ArrayRef,
    );



The ArrayRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ArrayRef function can be used to throw an exception if the argument can not be validated. The is_ArrayRef function can be used to return true or false if the argument can not be validated.

    Bool



    has data => (
        is  => rw,
        isa => Bool,
    );



The Bool type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Bool function can be used to throw an exception if the argument can not be validated. The is_Bool function can be used to return true or false if the argument can not be validated.

    ClassName



    has data => (
        is  => rw,
        isa => ClassName[MyClass],
    );



The ClassName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ClassName function can be used to throw an exception if the argument can not be validated. The is_ClassName function can be used to return true or false if the argument can not be validated.

    CodeObj



    has data => (
        is  => rw,
        isa => CodeObj,
    );



The CodeObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObj function can be used to throw an exception if the argument can not be validated. The is_CodeObj function can be used to return true or false if the argument can not be validated.

    CodeObject



    has data => (
        is  => rw,
        isa => CodeObject,
    );



The CodeObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObject function can be used to throw an exception if the argument can not be validated. The is_CodeObject function can be used to return true or false if the argument can not be validated.

    CodeRef



    has data => (
        is  => rw,
        isa => CodeRef,
    );



The CodeRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_CodeRef function can be used to throw an exception if the argument can not be validated. The is_CodeRef function can be used to return true or false if the argument can not be validated.

    ConsumerOf



    has data => (
        is  => rw,
        isa => ConsumerOf[MyRole],
    );



The ConsumerOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ConsumerOf function can be used to throw an exception if the argument can not be validated. The is_ConsumerOf function can be used to return true or false if the argument can not be validated.

    Defined



    has data => (
        is  => rw,
        isa => Defined,
    );



The Defined type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Defined function can be used to throw an exception if the argument can not be validated. The is_Defined function can be used to return true or false if the argument can not be validated.

    Dict



    has data => (
        is  => rw,
        isa => Dict,
    );



The Dict type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Dict function can be used to throw an exception if the argument can not be validated. The is_Dict function can be used to return true or false if the argument can not be validated.

    Enum



    has data => (
        is  => rw,
        isa => Enum,
    );



The Enum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Enum function can be used to throw an exception if the argument can not be validated. The is_Enum function can be used to return true or false if the argument can not be validated.

    FileHandle



    has data => (
        is  => rw,
        isa => FileHandle,
    );



The FileHandle type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_FileHandle function can be used to throw an exception if the argument can not be validated. The is_FileHandle function can be used to return true or false if the argument can not be validated.

    FloatObj



    has data => (
        is  => rw,
        isa => FloatObj,
    );



The FloatObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObj function can be used to throw an exception if the argument can not be validated. The is_FloatObj function can be used to return true or false if the argument can not be validated.

    FloatObject



    has data => (
        is  => rw,
        isa => FloatObject,
    );



The FloatObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObject function can be used to throw an exception if the argument can not be validated. The is_FloatObject function can be used to return true or false if the argument can not be validated.

    GlobRef



    has data => (
        is  => rw,
        isa => GlobRef,
    );



The GlobRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_GlobRef function can be used to throw an exception if the argument can not be validated. The is_GlobRef function can be used to return true or false if the argument can not be validated.

    HasMethods



    has data => (
        is  => rw,
        isa => HasMethods[...],
    );



The HasMethods type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HasMethods function can be used to throw an exception if the argument can not be validated. The is_HasMethods function can be used to return true or false if the argument can not be validated.

    HashObj



    has data => (
        is  => rw,
        isa => HashObj,
    );



The HashObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObj function can be used to throw an exception if the argument can not be validated. The is_HashObj function can be used to return true or false if the argument can not be validated.

    HashObject



    has data => (
        is  => rw,
        isa => HashObject,
    );



The HashObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObject function can be used to throw an exception if the argument can not be validated. The is_HashObject function can be used to return true or false if the argument can not be validated.

    HashRef



    has data => (
        is  => rw,
        isa => HashRef,
    );



The HashRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HashRef function can be used to throw an exception if the argument can not be validated. The is_HashRef function can be used to return true or false if the argument can not be validated.

    InstanceOf



    has data => (
        is  => rw,
        isa => InstanceOf[MyClass],
    );



The InstanceOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_InstanceOf function can be used to throw an exception if the argument can not be validated. The is_InstanceOf function can be used to return true or false if the argument can not be validated.

    Int



    has data => (
        is  => rw,
        isa => Int,
    );



The Int type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Int function can be used to throw an exception if the argument can not be validated. The is_Int function can be used to return true or false if the argument can not be validated.

    IntObj



    has data => (
        is  => rw,
        isa => IntObj,
    );



The IntObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObj function can be used to throw an exception if the argument can not be validated. The is_IntObj function can be used to return true or false if the argument can not be validated.

    IntObject



    has data => (
        is  => rw,
        isa => IntObject,
    );



The IntObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObject function can be used to throw an exception if the argument can not be validated. The is_IntObject function can be used to return true or false if the argument can not be validated.

    IntegerObj



    has data => (
        is  => rw,
        isa => IntegerObj,
    );



The IntegerObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObj function can be used to throw an exception if the argument can not be validated. The is_IntegerObj function can be used to return true or false if the argument can not be validated.

    IntegerObject



    has data => (
        is  => rw,
        isa => IntegerObject,
    );



The IntegerObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObject function can be used to throw an exception if the argument can not be validated. The is_IntegerObject function can be used to return true or false if the argument can not be validated.

    Item



    has data => (
        is  => rw,
        isa => Item,
    );



The Item type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Item function can be used to throw an exception if the argument can not be validated. The is_Item function can be used to return true or false if the argument can not be validated.

    LaxNum



    has data => (
        is  => rw,
        isa => LaxNum,
    );



The LaxNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_LaxNum function can be used to throw an exception if the argument can not be validated. The is_LaxNum function can be used to return true or false if the argument can not be validated.

    LowerCaseSimpleStr



    has data => (
        is  => rw,
        isa => LowerCaseSimpleStr,
    );



The LowerCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_LowerCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_LowerCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

    LowerCaseStr



    has data => (
        is  => rw,
        isa => LowerCaseStr,
    );



The LowerCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

    Map



    has data => (
        is  => rw,
        isa => Map[Int, HashRef],
    );



The Map type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Map function can be used to throw an exception if the argument can not be validated. The is_Map function can be used to return true or false if the argument can not be validated.

    Maybe



    has data => (
        is  => rw,
        isa => Maybe,
    );



The Maybe type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Maybe function can be used to throw an exception if the argument can not be validated. The is_Maybe function can be used to return true or false if the argument can not be validated.

    NegativeInt



    has data => (
        is  => rw,
        isa => NegativeInt,
    );



The NegativeInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeInt function can be used to throw an exception if the argument can not be validated. The is_NegativeInt function can be used to return true or false if the argument can not be validated.

    NegativeNum



    has data => (
        is  => rw,
        isa => NegativeNum,
    );



The NegativeNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeNum function can be used to throw an exception if the argument can not be validated. The is_NegativeNum function can be used to return true or false if the argument can not be validated.

    NegativeOrZeroInt



    has data => (
        is  => rw,
        isa => NegativeOrZeroInt,
    );



The NegativeOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_NegativeOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_NegativeOrZeroInt function can be used to return true or false if the argument can not be validated. information.

    NegativeOrZeroNum



    has data => (
        is  => rw,
        isa => NegativeOrZeroNum,
    );



The NegativeOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

    NonEmptySimpleStr



    has data => (
        is  => rw,
        isa => NonEmptySimpleStr,
    );



The NonEmptySimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

    NonEmptyStr



    has data => (
        is  => rw,
        isa => NonEmptyStr,
    );



The NonEmptyStr type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

    Num



    has data => (
        is  => rw,
        isa => Num,
    );



The Num type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Num function can be used to throw an exception if the argument can not be validated. The is_Num function can be used to return true or false if the argument can not be validated.

    NumObj



    has data => (
        is  => rw,
        isa => NumObj,
    );



The NumObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObj function can be used to throw an exception if the argument can not be validated. The is_NumObj function can be used to return true or false if the argument can not be validated.

    NumObject



    has data => (
        is  => rw,
        isa => NumObject,
    );



The NumObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObject function can be used to throw an exception if the argument can not be validated. The is_NumObject function can be used to return true or false if the argument can not be validated.

    NumberObj



    has data => (
        is  => rw,
        isa => NumberObj,
    );



The NumberObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumberObj function can be used to throw an exception if the argument can not be validated. The is_NumberObj function can be used to return true or false if the argument can not be validated.

    NumberObject



    has data => (
        is  => rw,
        isa => NumberObject,
    );



The NumberObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumberObject function can be used to throw an exception if the argument can not be validated. The is_NumberObject function can be used to return true or false if the argument can not be validated.

    NumericCode



    has data => (
        is  => rw,
        isa => NumericCode,
    );



The NumericCode type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_NumericCode function can be used to throw an exception if the argument can not be validated. The is_NumericCode function can be used to return true or false if the argument can not be validated.

    Object



    has data => (
        is  => rw,
        isa => Object,
    );



The Object type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Object function can be used to throw an exception if the argument can not be validated. The is_Object function can be used to return true or false if the argument can not be validated.

    OptList



    has data => (
        is  => rw,
        isa => OptList,
    );



The OptList type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_OptList function can be used to throw an exception if the argument can not be validated. The is_OptList function can be used to return true or false if the argument can not be validated.

    Optional



    has data => (
        is  => rw,
        isa => Dict[id => Optional[Int]],
    );



The Optional type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Optional function can be used to throw an exception if the argument can not be validated. The is_Optional function can be used to return true or false if the argument can not be validated.

    Overload



    has data => (
        is  => rw,
        isa => Overload,
    );



The Overload type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Overload function can be used to throw an exception if the argument can not be validated. The is_Overload function can be used to return true or false if the argument can not be validated.

    Password



    has data => (
        is  => rw,
        isa => Password,
    );



The Password type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Password function can be used to throw an exception if the argument can not be validated. The is_Password function can be used to return true or false if the argument can not be validated.

    PositiveInt



    has data => (
        is  => rw,
        isa => PositiveInt,
    );



The PositiveInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveInt function can be used to throw an exception if the argument can not be validated. The is_PositiveInt function can be used to return true or false if the argument can not be validated.

    PositiveNum



    has data => (
        is  => rw,
        isa => PositiveNum,
    );



The PositiveNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveNum function can be used to throw an exception if the argument can not be validated. The is_PositiveNum function can be used to return true or false if the argument can not be validated.

    PositiveOrZeroInt



    has data => (
        is  => rw,
        isa => PositiveOrZeroInt,
    );



The PositiveOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_PositiveOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_PositiveOrZeroInt function can be used to return true or false if the argument can not be validated. information.

    PositiveOrZeroNum



    has data => (
        is  => rw,
        isa => PositiveOrZeroNum,
    );



The PositiveOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

    Ref



    has data => (
        is  => rw,
        isa => Ref[SCALAR],
    );



The Ref type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

    RegexpObj



    has data => (
        is  => rw,
        isa => RegexpObj,
    );



The RegexpObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObj function can be used to throw an exception if the argument can not be validated. The is_RegexpObj function can be used to return true or false if the argument can not be validated.

    RegexpObject



    has data => (
        is  => rw,
        isa => RegexpObject,
    );



The RegexpObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObject function can be used to throw an exception if the argument can not be validated. The is_RegexpObject function can be used to return true or false if the argument can not be validated.

    RegexpRef



    has data => (
        is  => rw,
        isa => RegexpRef,
    );



The RegexpRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RegexpRef function can be used to throw an exception if the argument can not be validated. The is_RegexpRef function can be used to return true or false if the argument can not be validated.

    RoleName



    has data => (
        is  => rw,
        isa => RoleName,
    );



The RoleName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RoleName function can be used to throw an exception if the argument can not be validated. The is_RoleName function can be used to return true or false if the argument can not be validated.

    ScalarObj



    has data => (
        is  => rw,
        isa => ScalarObj,
    );



The ScalarObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObj function can be used to throw an exception if the argument can not be validated. The is_ScalarObj function can be used to return true or false if the argument can not be validated.

    ScalarObject



    has data => (
        is  => rw,
        isa => ScalarObject,
    );



The ScalarObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObject function can be used to throw an exception if the argument can not be validated. The is_ScalarObject function can be used to return true or false if the argument can not be validated.

    ScalarRef



    has data => (
        is  => rw,
        isa => ScalarRef,
    );



The ScalarRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ScalarRef function can be used to throw an exception if the argument can not be validated. The is_ScalarRef function can be used to return true or false if the argument can not be validated.

    SimpleStr



    has data => (
        is  => rw,
        isa => SimpleStr,
    );



The SimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_SimpleStr function can be used to throw an exception if the argument can not be validated. The is_SimpleStr function can be used to return true or false if the argument can not be validated.

    SingleDigit



    has data => (
        is  => rw,
        isa => SingleDigit,
    );



The SingleDigit type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_SingleDigit function can be used to throw an exception if the argument can not be validated. The is_SingleDigit function can be used to return true or false if the argument can not be validated.

    Str



    has data => (
        is  => rw,
        isa => Str,
    );



The Str type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Str function can be used to throw an exception if the argument can not be validated. The is_Str function can be used to return true or false if the argument can not be validated.

    StrMatch



    has data => (
        is  => rw,
        isa => StrMatch,
    );



The StrMatch type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrMatch function can be used to throw an exception if the argument can not be validated. The is_StrMatch function can be used to return true or false if the argument can not be validated.

    StrObj



    has data => (
        is  => rw,
        isa => StrObj,
    );



The StrObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObj function can be used to throw an exception if the argument can not be validated. The is_StrObj function can be used to return true or false if the argument can not be validated.

    StrObject



    has data => (
        is  => rw,
        isa => StrObject,
    );



The StrObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObject function can be used to throw an exception if the argument can not be validated. The is_StrObject function can be used to return true or false if the argument can not be validated.

    StrictNum



    has data => (
        is  => rw,
        isa => StrictNum,
    );



The StrictNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrictNum function can be used to throw an exception if the argument can not be validated. The is_StrictNum function can be used to return true or false if the argument can not be validated.

    StringObj



    has data => (
        is  => rw,
        isa => StringObj,
    );



The StringObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObj function can be used to throw an exception if the argument can not be validated. The is_StringObj function can be used to return true or false if the argument can not be validated.

    StringObject



    has data => (
        is  => rw,
        isa => StringObject,
    );



The StringObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObject function can be used to throw an exception if the argument can not be validated. The is_StringObject function can be used to return true or false if the argument can not be validated.

    StrongPassword



    has data => (
        is  => rw,
        isa => StrongPassword,
    );



The StrongPassword type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_StrongPassword function can be used to throw an exception if the argument can not be validated. The is_StrongPassword function can be used to return true or false if the argument can not be validated.

    Tied



    has data => (
        is  => rw,
        isa => Tied[MyClass],
    );



The Tied type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tied function can be used to throw an exception if the argument can not be validated. The is_Tied function can be used to return true or false if the argument can not be validated.

    Tuple



    has data => (
        is  => rw,
        isa => Tuple[Int, Str, Str],
    );



The Tuple type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tuple function can be used to throw an exception if the argument can not be validated. The is_Tuple function can be used to return true or false if the argument can not be validated.

    Undef



    has data => (
        is  => rw,
        isa => Undef,
    );



The Undef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Undef function can be used to throw an exception if the argument can not be validated. The is_Undef function can be used to return true or false if the argument can not be validated.

    UndefObj



    has data => (
        is  => rw,
        isa => UndefObj,
    );



The UndefObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObj function can be used to throw an exception if the argument can not be validated. The is_UndefObj function can be used to return true or false if the argument can not be validated.

    UndefObject



    has data => (
        is  => rw,
        isa => UndefObject,
    );



The UndefObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObject function can be used to throw an exception if the argument can not be validated. The is_UndefObject function can be used to return true or false if the argument can not be validated.

    UniversalObj



    has data => (
        is  => rw,
        isa => UniversalObj,
    );



The UniversalObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Universal object. The assert_UniversalObj function can be used to throw an exception if the argument can not be validated. The is_UniversalObj function can be used to return true or false if the argument can not be validated.

    UniversalObject



    has data => (
        is  => rw,
        isa => UniversalObject,
    );



The UniversalObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Universal object. The assert_UniversalObject function can be used to throw an exception if the argument can not be validated. The is_UniversalObject function can be used to return true or false if the argument can not be validated.

    UpperCaseSimpleStr



    has data => (
        is  => rw,
        isa => UpperCaseSimpleStr,
    );



The UpperCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_UpperCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_UpperCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

    UpperCaseStr



    has data => (
        is  => rw,
        isa => UpperCaseStr,
    );



The UpperCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

    Value



    has data => (
        is  => rw,
        isa => Value,
    );



The Value type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Value function can be used to throw an exception if the argument can not be validated. The is_Value function can be used to return true or false if the argument can not be validated.

SEE ALSO

o Data::Object::Array
o Data::Object::Class
o Data::Object::Class::Syntax
o Data::Object::Code
o Data::Object::Float
o Data::Object::Hash
o Data::Object::Integer
o Data::Object::Number
o Data::Object::Role
o Data::Object::Role::Syntax
o Data::Object::Regexp
o Data::Object::Scalar
o Data::Object::String
o Data::Object::Undef
o Data::Object::Universal
o Data::Object::Autobox
o Data::Object::Immutable
o Data::Object::Library
o Data::Object::Prototype
o Data::Object::Signatures

AUTHOR

Al Newkirk <anewkirk@ana.io>

COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Al Newkirk.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.

Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 DATA::OBJECT::LIBRARY (3) 2015-11-29

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.