|  |  | 
package XML::Schema::Type::whatever; use XML::Schema::Type::Builtin; use base qw( XML::Schema::Type::Simple ); use vars qw( @FACETS ); @FACETS = ( minLength => 10, maxLength => 30, otherFacet => { value => $n, fixed => 1, annotation => "a comment", }, ); package main; my $type = XML::Schema::Type::whatever->new() || die XML::Schema::Type::whatever->error(); my $item = $type->instance('some instance value') || die $type->error(); print $item->{ result };
The XML::Schema::Type::Simple module implements a base class from which the builtin simple datatypes like string, integer, float and time (all defined in XML::Schema::Type::Builtin) are subclassed. It can also be used as a base class for creating user defined simple types.
Simple data types are used to represent single values in XML documents, appearing as attribute values or the content of simple elements.
    Here's an example showing an element with attributes
    id and price, with corresponding
    values widget99 and 19.99.  The
    XML Schema fragment for this element would typically 
    define id as having simple type 
    integer,
    and price as 
    money,
  
<product id="widget99" price="19.99"/>
    Simple types are also be used to represent to content 
    of simple elements.  These are elements that have no attributes or
    nested elements.  The previous example could instead have defined
    <price> as a simple element within
    <constant>, having a content type of 
    money.
<product id="widget99"> <price>19.99</price> </product>
The schema used to represent these different examples is different, as is the resulting data set generated by parsing these examples. However, in both cases, it is a simple type object (e.g. XML::Schema::Type::money) used to represent the value(s) for both attributes and simple elements.
    Simple types use validation facets which implement
    different aspects of validation for different types.  These are
    used internally to specialise existing types.  For example, the
    positiveInteger simple type is derived from the
    integer type by adding a facet which encodes the
    constraint minInclusive => 1.
    
Facets can subsequently be applied to simple types to create user defined specialised types. To constrain a number to an integer value between 1 and 32, you might do the following.
my $type = XML::Schema::Type::positiveInteger->new(); $type->constrain( maxInclusive => 32 );
     Now, when you try to create an instance of this type via the
     instance() method, the value passed will first
     be validated against the internal minInclusive => 1
     facet and then against the user-defined maxInclusive =>
     32 facet.
    
my $item = $type->instance(14) || die $type->error();
    The value returned from a successful call to
    instance() is a reference to a hash array which
    represents the infoset generated by creating an instance of
    the type for a particular input value.  Although a simple type
    starts off as a simple string, it may get broken down into all
    manner of different components.  For example, the
    time simple type returns an infoset containing values
    for hour, minute, second
    and so on.
    
    The infoset hash has a text item to indicate the
    original input text.  This is copied to the value
    item which validation facets then use as a working copy to modify
    and manipulate as necessary.  Facets may also make any number of
    other contributions to the infoset depending on their and the 
    underlying data types.  
    
    If all facets validate successfully then the resultant
    value value is copied to the result
    value.  If any callbacks have been scheduled for activation
    then these are called and may modify the result
    further.
print $item->{ result };
    In summary, the hash array returned by the
    instance() should contain at least a
    text member containing the original text, a
    value containing the possibly modified
    post-validation value, and result containing the
    post-activation result which may be some alternate representation
    of the validated text (e.g. text converted to an object reference
    by a user-defined scheduled action).
    
This might all seem rather cumbersome, but it's generally not something you have to worry about. The higher level components generally take care of the nitty gritty detail for you.