Data::Object::Config::Library
Data-Object Library Configuration
use Data::Object::Config::Library;
Data::Object::Config::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.
This package can export the following type constraints.
has data => ( is => 'ro', 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.
assert_Any
is_Any
has data => ( is => 'ro', isa => 'AnyObj', );
The AnyObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Any 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.
assert_AnyObj
is_AnyObj
has data => ( is => 'ro', isa => 'AnyObject', );
The AnyObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Any 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.
assert_AnyObject
is_AnyObject
has data => ( is => 'ro', 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.
assert_ArrayObj
is_ArrayObj
has data => ( is => 'ro', 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.
assert_ArrayObject
is_ArrayObject
has data => ( is => 'ro', 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.
assert_ArrayRef function
is_ArrayRef
has data => ( is => 'ro', 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.
assert_Bool
is_Bool
has data => ( is => 'ro', 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.
assert_ClassName function
is_ClassName
has data => ( is => 'ro', 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.
assert_CodeObj function
is_CodeObj
has data => ( is => 'ro', 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.
assert_CodeObject
is_CodeObject
has data => ( is => 'ro', 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.
assert_CodeRef
is_CodeRef
has data => ( is => 'ro', 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.
assert_ConsumerOf function
is_ConsumerOf
has data => ( is => 'ro', isa => 'DataObj', );
The DataObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObj function can be used to throw an exception if the argument can not be validated. The is_DataObj function can be used to return true or false if the argument can not be validated.
assert_DataObj
is_DataObj
has data => ( is => 'ro', isa => 'DataObject', );
The DataObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObject function can be used to throw an exception if the argument can not be validated. The is_DataObject function can be used to return true or false if the argument can not be validated.
assert_DataObject
is_DataObject
has data => ( is => 'ro', 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.
assert_Defined
is_Defined
has data => ( is => 'ro', 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.
assert_Dict
is_Dict
has data => ( is => 'ro', isa => 'DispatchObj', );
The DispatchObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Dispatch object. The assert_DispatchObj function can be used to throw an exception if the argument can not be validated. The is_DispatchObj function can be used to return true or false if the argument can not be validated.
assert_DispatchObj
is_DispatchObj
has data => ( is => 'ro', isa => 'DispatchObject', );
The DispatchObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Dispatch object. The assert_DispatchObject function can be used to throw an exception if the argument can not be validated. The is_DispatchObject function can be used to return true or false if the argument can not be validated.
assert_DispatchObject
is_DispatchObject
has data => ( is => 'ro', 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.
assert_Enum
is_Enum
has data => ( is => 'ro', isa => 'ExceptionObj', );
The ExceptionObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObj function can be used to throw an exception if the argument can not be validated. The is_ExceptionObj function can be used to return true or false if the argument can not be validated.
assert_ExceptionObj
is_ExceptionObj
has data => ( is => 'ro', isa => 'ExceptionObject', );
The ExceptionObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObject function can be used to throw an exception if the argument can not be validated. The is_ExceptionObject function can be used to return true or false if the argument can not be validated.
assert_ExceptionObject
is_ExceptionObject
has data => ( is => 'ro', 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.
assert_FileHandle function
is_FileHandle
has data => ( is => 'ro', 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.
assert_FloatObj
is_FloatObj
has data => ( is => 'ro', 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.
assert_FloatObject
is_FloatObject
has data => ( is => 'ro', isa => 'FuncObj', );
The FuncObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObj function can be used to throw an exception if the argument can not be validated. The is_FuncObj function can be used to return true or false if the argument can not be validated.
assert_FuncObj
is_FuncObj
has data => ( is => 'ro', isa => 'FuncObject', );
The FuncObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObject function can be used to throw an exception if the argument can not be validated. The is_FuncObject function can be used to return true or false if the argument can not be validated.
assert_FuncObject
is_FuncObject
has data => ( is => 'ro', 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.
assert_GlobRef
is_GlobRef
has data => ( is => 'ro', 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.
assert_HasMethods function
is_HasMethods
has data => ( is => 'ro', 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.
assert_HashObj function
is_HashObj
has data => ( is => 'ro', 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.
assert_HashObject
is_HashObject
has data => ( is => 'ro', 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.
assert_HashRef
is_HashRef
has data => ( is => 'ro', 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.
assert_InstanceOf function
is_InstanceOf
has data => ( is => 'ro', 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.
assert_Int
is_Int
has data => ( is => 'ro', 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.
assert_IntObj
is_IntObj
has data => ( is => 'ro', 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.
assert_IntObject
is_IntObject
has data => ( is => 'ro', 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.
assert_IntegerObj
is_IntegerObj
has data => ( is => 'ro', 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.
assert_IntegerObject
is_IntegerObject
has data => ( is => 'ro', 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.
assert_Item
is_Item
has data => ( is => 'ro', isa => 'JsonObj', );
The JsonObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Json object. The assert_JsonObj function can be used to throw an exception if the argument can not be validated. The is_JsonObj function can be used to return true or false if the argument can not be validated.
assert_JsonObj
is_JsonObj
has data => ( is => 'ro', isa => 'JsonObject', );
The JsonObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Json object. The assert_JsonObject function can be used to throw an exception if the argument can not be validated. The is_JsonObject function can be used to return true or false if the argument can not be validated.
assert_JsonObject
is_JsonObject
has data => ( is => 'ro', 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.
assert_LaxNum
is_LaxNum
has data => ( is => 'ro', 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.
assert_LowerCaseSimpleStr
is_LowerCaseSimpleStr
has data => ( is => 'ro', 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.
assert_type function
is_type
has data => ( is => 'ro', 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.
assert_Map
is_Map
has data => ( is => 'ro', 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.
assert_Maybe
is_Maybe
has data => ( is => 'ro', 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.
assert_NegativeInt
is_NegativeInt
has data => ( is => 'ro', 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.
assert_NegativeNum
is_NegativeNum
has data => ( is => 'ro', 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.
assert_NegativeOrZeroInt
is_NegativeOrZeroInt
has data => ( is => 'ro', 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.
assert_type
has data => ( is => 'ro', 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.
has data => ( is => 'ro', 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.
has data => ( is => 'ro', 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.
assert_Num
is_Num
has data => ( is => 'ro', 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.
assert_NumObj
is_NumObj
has data => ( is => 'ro', 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.
assert_NumObject
is_NumObject
has data => ( is => 'ro', 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.
assert_NumberObj
is_NumberObj
has data => ( is => 'ro', 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.
assert_NumberObject
is_NumberObject
has data => ( is => 'ro', 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.
assert_NumericCode
is_NumericCode
has data => ( is => 'ro', 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.
assert_Object
is_Object
has data => ( is => 'ro', 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.
assert_OptList
is_OptList
has data => ( is => 'ro', 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.
assert_Optional function
is_Optional
has data => ( is => 'ro', 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.
assert_Overload function
is_Overload
has data => ( is => 'ro', 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.
assert_Password function
is_Password
has data => ( is => 'ro', isa => 'PathObj', );
The PathObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Path object. The assert_PathObj function can be used to throw an exception if the argument can not be validated. The is_PathObj function can be used to return true or false if the argument can not be validated.
assert_PathObj
is_PathObj
has data => ( is => 'ro', isa => 'PathObject', );
The PathObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Path object. The assert_PathObject function can be used to throw an exception if the argument can not be validated. The is_PathObject function can be used to return true or false if the argument can not be validated.
assert_PathObject
is_PathObject
has data => ( is => 'ro', 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.
assert_PositiveInt
is_PositiveInt
has data => ( is => 'ro', 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.
assert_PositiveNum
is_PositiveNum
has data => ( is => 'ro', 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.
assert_PositiveOrZeroInt
is_PositiveOrZeroInt
has data => ( is => 'ro', 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.
has data => ( is => 'ro', 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.
has data => ( is => 'ro', 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.
assert_RegexpObj
is_RegexpObj
has data => ( is => 'ro', 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.
assert_RegexpObject
is_RegexpObject
has data => ( is => 'ro', 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.
assert_RegexpRef function
is_RegexpRef
has data => ( is => 'ro', isa => 'ReplaceObj', );
The ReplaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObj function can be used to throw an exception if the argument can not be validated. The is_ReplaceObj function can be used to return true or false if the argument can not be validated.
assert_ReplaceObj
is_ReplaceObj
has data => ( is => 'ro', isa => 'ReplaceObject', );
The ReplaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObject function can be used to throw an exception if the argument can not be validated. The is_ReplaceObject function can be used to return true or false if the argument can not be validated.
assert_ReplaceObject
is_ReplaceObject
has data => ( is => 'ro', 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.
assert_RoleName function
is_RoleName
has data => ( is => 'ro', 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.
assert_ScalarObj
is_ScalarObj
has data => ( is => 'ro', 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.
assert_ScalarObject
is_ScalarObject
has data => ( is => 'ro', 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.
assert_ScalarRef function
is_ScalarRef
has data => ( is => 'ro', isa => 'SearchObj', );
The SearchObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObj function can be used to throw an exception if the argument can not be validated. The is_SearchObj function can be used to return true or false if the argument can not be validated.
assert_SearchObj
is_SearchObj
has data => ( is => 'ro', isa => 'SearchObject', );
The SearchObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObject function can be used to throw an exception if the argument can not be validated. The is_SearchObject function can be used to return true or false if the argument can not be validated.
assert_SearchObject
is_SearchObject
has data => ( is => 'ro', 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.
assert_SimpleStr
is_SimpleStr
has data => ( is => 'ro', 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.
assert_SingleDigit
is_SingleDigit
has data => ( is => 'ro', isa => 'SpaceObj', );
The SpaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObj function can be used to throw an exception if the argument can not be validated. The is_SpaceObj function can be used to return true or false if the argument can not be validated.
assert_SpaceObj
is_SpaceObj
has data => ( is => 'ro', isa => 'SpaceObject', );
The SpaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObject function can be used to throw an exception if the argument can not be validated. The is_SpaceObject function can be used to return true or false if the argument can not be validated.
assert_SpaceObject
is_SpaceObject
has data => ( is => 'ro', 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.
assert_Str
is_Str
has data => ( is => 'ro', 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.
assert_StrMatch function
is_StrMatch
has data => ( is => 'ro', 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.
assert_StrObj
is_StrObj
has data => ( is => 'ro', 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.
assert_StrObject
is_StrObject
has data => ( is => 'ro', 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.
assert_StrictNum function
is_StrictNum
has data => ( is => 'ro', 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.
assert_StringObj
is_StringObj
has data => ( is => 'ro', 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.
assert_StringObject
is_StringObject
has data => ( is => 'ro', 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.
assert_StrongPassword
is_StrongPassword
has data => ( is => 'ro', isa => 'TemplateObj', );
The TemplateObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Template object. The assert_TemplateObj function can be used to throw an exception if the argument can not be validated. The is_TemplateObj function can be used to return true or false if the argument can not be validated.
assert_TemplateObj
is_TemplateObj
has data => ( is => 'ro', isa => 'TemplateObject', );
The TemplateObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Template object. The assert_TemplateObject function can be used to throw an exception if the argument can not be validated. The is_TemplateObject function can be used to return true or false if the argument can not be validated.
assert_TemplateObject
is_TemplateObject
has data => ( is => 'ro', 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.
assert_Tied
is_Tied
has data => ( is => 'ro', 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.
assert_Tuple
is_Tuple
has data => ( is => 'ro', 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.
assert_Undef
is_Undef
has data => ( is => 'ro', 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.
assert_UndefObj
is_UndefObj
has data => ( is => 'ro', 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.
assert_UndefObject
is_UndefObject
has data => ( is => 'ro', 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.
assert_UpperCaseSimpleStr
is_UpperCaseSimpleStr
has data => ( is => 'ro', 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.
has data => ( is => 'ro', 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.
assert_Value
is_Value
has data => ( is => 'ro', isa => 'YamlObj', );
The YamlObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Yaml object. The assert_YamlObj function can be used to throw an exception if the argument can not be validated. The is_YamlObj function can be used to return true or false if the argument can not be validated.
assert_YamlObj
is_YamlObj
has data => ( is => 'ro', isa => 'YamlObject', );
The YamlObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Yaml object. The assert_YamlObject function can be used to throw an exception if the argument can not be validated. The is_YamlObject function can be used to return true or false if the argument can not be validated.
assert_YamlObject
is_YamlObject
To install Data::Object, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Data::Object
CPAN shell
perl -MCPAN -e shell install Data::Object
For more information on module installation, please visit the detailed CPAN module installation guide.