xmlschemastypes: implementation of XML Schema Datatypes

## xmlschemastypes

xmlschemastypes - implementation of XML Schema Datatypes

module providing the XML Schema Datatypes implementation both definition and validity checking

Author(s): Daniel Veillard

## Synopsis

    typedef enum xmlSchemaWhitespaceValueType;
    int	xmlSchemaValPredefTypeNode	(xmlSchemaTypePtr type,
    					 const xmlChar * value,
    					 xmlSchemaValPtr * val,
    					 xmlNodePtr node);
    int	xmlSchemaGetCanonValueWhtsp	(xmlSchemaValPtr val,
    					 const xmlChar ** retValue,
    					 xmlSchemaWhitespaceValueType ws);
    int	xmlSchemaValidateLengthFacetWhtsp	(xmlSchemaFacetPtr facet,
    						 xmlSchemaValType valType,
    						 const xmlChar * value,
    						 xmlSchemaValPtr val,
    						 unsigned long * length,
    						 xmlSchemaWhitespaceValueType ws);
    int	xmlSchemaIsBuiltInTypeFacet	(xmlSchemaTypePtr type,
    					 int facetType);
    int	xmlSchemaGetCanonValue		(xmlSchemaValPtr val,
    					 const xmlChar ** retValue);
    xmlSchemaTypePtr	xmlSchemaGetBuiltInListSimpleTypeItemType	(xmlSchemaTypePtr type);
    int	xmlSchemaCompareValuesWhtsp	(xmlSchemaValPtr x,
    					 xmlSchemaWhitespaceValueType xws,
    					 xmlSchemaValPtr y,
    					 xmlSchemaWhitespaceValueType yws);
    int	xmlSchemaValueGetAsBoolean	(xmlSchemaValPtr val);
    xmlChar *	xmlSchemaCollapseString	(const xmlChar * value);
    int	xmlSchemaValPredefTypeNodeNoNorm	(xmlSchemaTypePtr type,
    						 const xmlChar * value,
    						 xmlSchemaValPtr * val,
    						 xmlNodePtr node);
    int	xmlSchemaValidateFacet		(xmlSchemaTypePtr base,
    					 xmlSchemaFacetPtr facet,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val);
    xmlSchemaFacetPtr	xmlSchemaNewFacet	(void);
    int	xmlSchemaValueAppend		(xmlSchemaValPtr prev,
    					 xmlSchemaValPtr cur);
    int	xmlSchemaCompareValues		(xmlSchemaValPtr x,
    					 xmlSchemaValPtr y);
    int	xmlSchemaValidateLengthFacet	(xmlSchemaTypePtr type,
    					 xmlSchemaFacetPtr facet,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val,
    					 unsigned long * length);
    xmlSchemaValType	xmlSchemaGetValType	(xmlSchemaValPtr val);
    xmlSchemaTypePtr	xmlSchemaGetPredefinedType	(const xmlChar * name,
    							 const xmlChar * ns);
    int	xmlSchemaValidatePredefinedType	(xmlSchemaTypePtr type,
    					 const xmlChar * value,
    					 xmlSchemaValPtr * val);
    void	xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet);
    int	xmlSchemaValidateListSimpleTypeFacet	(xmlSchemaFacetPtr facet,
    						 const xmlChar * value,
    						 unsigned long actualLen,
    						 unsigned long * expectedLen);
    unsigned long	xmlSchemaGetFacetValueAsULong	(xmlSchemaFacetPtr facet);
    void	xmlSchemaFreeValue		(xmlSchemaValPtr value);
    xmlSchemaValPtr	xmlSchemaValueGetNext	(xmlSchemaValPtr cur);
    const xmlChar *	xmlSchemaValueGetAsString	(xmlSchemaValPtr val);
    xmlSchemaValPtr	xmlSchemaCopyValue	(xmlSchemaValPtr val);
    xmlSchemaValPtr	xmlSchemaNewNOTATIONValue	(const xmlChar * name,
    						 const xmlChar * ns);
    xmlSchemaValPtr	xmlSchemaNewQNameValue	(const xmlChar * namespaceName,
    					 const xmlChar * localName);
    void	xmlSchemaCleanupTypes		(void);
    xmlChar *	xmlSchemaWhiteSpaceReplace	(const xmlChar * value);
    xmlSchemaValPtr	xmlSchemaNewStringValue	(xmlSchemaValType type,
    					 const xmlChar * value);
    xmlSchemaTypePtr	xmlSchemaGetBuiltInType	(xmlSchemaValType type);
    void	xmlSchemaInitTypes		(void);
    int	xmlSchemaValidateFacetWhtsp	(xmlSchemaFacetPtr facet,
    					 xmlSchemaWhitespaceValueType fws,
    					 xmlSchemaValType valType,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val,
    					 xmlSchemaWhitespaceValueType ws);
    int	xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
    					 xmlSchemaTypePtr typeDecl,
    					 xmlSchemaParserCtxtPtr pctxt,
    					 const xmlChar * name);

## Description

## Details

### Enum xmlSchemaWhitespaceValueType

    enum xmlSchemaWhitespaceValueType {
        XML_SCHEMA_WHITESPACE_UNKNOWN = 0
        XML_SCHEMA_WHITESPACE_PRESERVE = 1
        XML_SCHEMA_WHITESPACE_REPLACE = 2
        XML_SCHEMA_WHITESPACE_COLLAPSE = 3
    };

### xmlSchemaCheckFacet ()

    int	xmlSchemaCheckFacet		(xmlSchemaFacetPtr facet,
    					 xmlSchemaTypePtr typeDecl,
    					 xmlSchemaParserCtxtPtr pctxt,
    					 const xmlChar * name)

Checks and computes the values of facets.

`facet`: | the facet
`typeDecl`: | the schema type definition
`pctxt`: | the schema parser context or NULL
`name`: | the optional name of the type
`Returns`: | 0 if valid, a positive error code if not valid and -1 in case of an internal or API error.

### xmlSchemaCleanupTypes ()

    void	xmlSchemaCleanupTypes		(void)

Cleanup the default XML Schemas type library

### xmlSchemaCollapseString ()

    xmlChar *	xmlSchemaCollapseString	(const xmlChar * value)

Removes and normalize white spaces in the string

`value`: | a value
`Returns`: | the new string or NULL if no change was required.

### xmlSchemaCompareValues ()

    int	xmlSchemaCompareValues		(xmlSchemaValPtr x,
    					 xmlSchemaValPtr y)

Compare 2 values

`x`: | a first value
`y`: | a second value
`Returns`: | -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in case of error

### xmlSchemaCompareValuesWhtsp ()

    int	xmlSchemaCompareValuesWhtsp	(xmlSchemaValPtr x,
    					 xmlSchemaWhitespaceValueType xws,
    					 xmlSchemaValPtr y,
    					 xmlSchemaWhitespaceValueType yws)

Compare 2 values

`x`: | a first value
`xws`: | the whitespace value of x
`y`: | a second value
`yws`: | the whitespace value of y
`Returns`: | -1 if x < y, 0 if x == y, 1 if x > y, 2 if x <> y, and -2 in case of error

### xmlSchemaCopyValue ()

    xmlSchemaValPtr	xmlSchemaCopyValue	(xmlSchemaValPtr val)

Copies the precomputed value. This duplicates any string within.

`val`: | the precomputed value to be copied
`Returns`: | the copy or NULL if a copy for a data-type is not implemented.

### xmlSchemaFreeFacet ()

    void	xmlSchemaFreeFacet		(xmlSchemaFacetPtr facet)

Deallocate a Schema Facet structure.

`facet`: | a schema facet structure

### xmlSchemaFreeValue ()

    void	xmlSchemaFreeValue		(xmlSchemaValPtr value)

Cleanup the default XML Schemas type library

`value`: | the value to free

### xmlSchemaGetBuiltInListSimpleTypeItemType ()

    xmlSchemaTypePtr	xmlSchemaGetBuiltInListSimpleTypeItemType	(xmlSchemaTypePtr type)

Lookup function

`type`: | the built-in simple type.
`Returns`: | the item type of @type as defined by the built-in datatype hierarchy of XML Schema Part 2: Datatypes, or NULL in case of an error.

### xmlSchemaGetBuiltInType ()

    xmlSchemaTypePtr	xmlSchemaGetBuiltInType	(xmlSchemaValType type)

Gives you the type struct for a built-in type by its type id.

`type`: | the type of the built in type
`Returns`: | the type if found, NULL otherwise.

### xmlSchemaGetCanonValue ()

    int	xmlSchemaGetCanonValue		(xmlSchemaValPtr val,
    					 const xmlChar ** retValue)

Get the canonical lexical representation of the value. The caller has to FREE the returned retValue. WARNING: Some value types are not supported yet, resulting in a @retValue of "???". TODO: XML Schema 1.0 does not define canonical representations for: duration, gYearMonth, gYear, gMonthDay, gMonth, gDay, anyURI, QName, NOTATION. This will be fixed in XML Schema 1.1.

`val`: | the precomputed value
`retValue`: | the returned value
`Returns`: | 0 if the value could be built, 1 if the value type is not supported yet and -1 in case of API errors.

### xmlSchemaGetCanonValueWhtsp ()

    int	xmlSchemaGetCanonValueWhtsp	(xmlSchemaValPtr val,
    					 const xmlChar ** retValue,
    					 xmlSchemaWhitespaceValueType ws)

Get the canonical representation of the value. The caller has to free the returned @retValue.

`val`: | the precomputed value
`retValue`: | the returned value
`ws`: | the whitespace type of the value
`Returns`: | 0 if the value could be built, 1 if the value type is not supported yet and -1 in case of API errors.

### xmlSchemaGetFacetValueAsULong ()

    unsigned long	xmlSchemaGetFacetValueAsULong	(xmlSchemaFacetPtr facet)

Extract the value of a facet

`facet`: | an schemas type facet
`Returns`: | the value as a long

### xmlSchemaGetPredefinedType ()

    xmlSchemaTypePtr	xmlSchemaGetPredefinedType	(const xmlChar * name,
    							 const xmlChar * ns)

Lookup a type in the default XML Schemas type library

`name`: | the type name
`ns`: | the URI of the namespace usually "http://www.w3.org/2001/XMLSchema"
`Returns`: | the type if found, NULL otherwise

### xmlSchemaGetValType ()

    xmlSchemaValType	xmlSchemaGetValType	(xmlSchemaValPtr val)

Accessor for the type of a value

`val`: | a schemas value
`Returns`: | the xmlSchemaValType of the value

### xmlSchemaInitTypes ()

    void	xmlSchemaInitTypes		(void)

Initialize the default XML Schemas type library

### xmlSchemaIsBuiltInTypeFacet ()

    int	xmlSchemaIsBuiltInTypeFacet	(xmlSchemaTypePtr type,
    					 int facetType)

Evaluates if a specific facet can be used in conjunction with a type.

`type`: | the built-in type
`facetType`: | the facet type
`Returns`: | 1 if the facet can be used with the given built-in type, 0 otherwise and -1 in case the type is not a built-in type.

### xmlSchemaNewFacet ()

    xmlSchemaFacetPtr	xmlSchemaNewFacet	(void)

Allocate a new Facet structure.

`Returns`: | the newly allocated structure or NULL in case or error

### xmlSchemaNewNOTATIONValue ()

    xmlSchemaValPtr	xmlSchemaNewNOTATIONValue	(const xmlChar * name,
    						 const xmlChar * ns)

Allocate a new NOTATION value. The given values are consumed and freed with the struct.

`name`: | the notation name
`ns`: | the notation namespace name or NULL
`Returns`: | a pointer to the new value or NULL in case of error

### xmlSchemaNewQNameValue ()

    xmlSchemaValPtr	xmlSchemaNewQNameValue	(const xmlChar * namespaceName,
    					 const xmlChar * localName)

Allocate a new QName value. The given values are consumed and freed with the struct.

`namespaceName`: | the namespace name
`localName`: | the local name
`Returns`: | a pointer to the new value or NULL in case of an error.

### xmlSchemaNewStringValue ()

    xmlSchemaValPtr	xmlSchemaNewStringValue	(xmlSchemaValType type,
    					 const xmlChar * value)

Allocate a new simple type value. The type can be of XML_SCHEMAS_STRING. WARNING: This one is intended to be expanded for other string based types. We need this for anySimpleType as well. The given value is consumed and freed with the struct.

`type`: | the value type
`value`: | the value
`Returns`: | a pointer to the new value or NULL in case of error

### xmlSchemaValPredefTypeNode ()

    int	xmlSchemaValPredefTypeNode	(xmlSchemaTypePtr type,
    					 const xmlChar * value,
    					 xmlSchemaValPtr * val,
    					 xmlNodePtr node)

Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val.

`type`: | the predefined type
`value`: | the value to check
`val`: | the return computed value
`node`: | the node containing the value
`Returns`: | 0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.

### xmlSchemaValPredefTypeNodeNoNorm ()

    int	xmlSchemaValPredefTypeNodeNoNorm	(xmlSchemaTypePtr type,
    						 const xmlChar * value,
    						 xmlSchemaValPtr * val,
    						 xmlNodePtr node)

Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val. This one does apply any normalization to the value.

`type`: | the predefined type
`value`: | the value to check
`val`: | the return computed value
`node`: | the node containing the value
`Returns`: | 0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.

### xmlSchemaValidateFacet ()

    int	xmlSchemaValidateFacet		(xmlSchemaTypePtr base,
    					 xmlSchemaFacetPtr facet,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val)

Check a value against a facet condition

`base`: | the base type
`facet`: | the facet to check
`value`: | the lexical repr of the value to validate
`val`: | the precomputed value
`Returns`: | 0 if the element is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.

### xmlSchemaValidateFacetWhtsp ()

    int	xmlSchemaValidateFacetWhtsp	(xmlSchemaFacetPtr facet,
    					 xmlSchemaWhitespaceValueType fws,
    					 xmlSchemaValType valType,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val,
    					 xmlSchemaWhitespaceValueType ws)

Check a value against a facet condition. This takes value normalization according to the specified whitespace types into account. Note that @value needs to be the *normalized* value if the facet is of type "pattern".

`facet`: | the facet to check
`fws`: | the whitespace type of the facet's value
`valType`: | the built-in type of the value
`value`: | the lexical (or normalized for pattern) repr of the value to validate
`val`: | the precomputed value
`ws`: | the whitespace type of the value
`Returns`: | 0 if the element is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.

### xmlSchemaValidateLengthFacet ()

    int	xmlSchemaValidateLengthFacet	(xmlSchemaTypePtr type,
    					 xmlSchemaFacetPtr facet,
    					 const xmlChar * value,
    					 xmlSchemaValPtr val,
    					 unsigned long * length)

Checka a value against a "length", "minLength" and "maxLength" facet; sets @length to the computed length of @value.

`type`: | the built-in type
`facet`: | the facet to check
`value`: | the lexical repr. of the value to be validated
`val`: | the precomputed value
`length`: | the actual length of the value
`Returns`: | 0 if the value is valid, a positive error code otherwise and -1 in case of an internal or API error.

### xmlSchemaValidateLengthFacetWhtsp ()

    int	xmlSchemaValidateLengthFacetWhtsp	(xmlSchemaFacetPtr facet,
    						 xmlSchemaValType valType,
    						 const xmlChar * value,
    						 xmlSchemaValPtr val,
    						 unsigned long * length,
    						 xmlSchemaWhitespaceValueType ws)

Checka a value against a "length", "minLength" and "maxLength" facet; sets @length to the computed length of @value.

`facet`: | the facet to check
`valType`: | the built-in type
`value`: | the lexical repr. of the value to be validated
`val`: | the precomputed value
`length`: | the actual length of the value
`ws`: | the whitespace type of the value
`Returns`: | 0 if the value is valid, a positive error code otherwise and -1 in case of an internal or API error.

### xmlSchemaValidateListSimpleTypeFacet ()

    int	xmlSchemaValidateListSimpleTypeFacet	(xmlSchemaFacetPtr facet,
    						 const xmlChar * value,
    						 unsigned long actualLen,
    						 unsigned long * expectedLen)

Checks the value of a list simple type against a facet.

`facet`: | the facet to check
`value`: | the lexical repr of the value to validate
`actualLen`: | the number of list items
`expectedLen`: | the resulting expected number of list items
`Returns`: | 0 if the value is valid, a positive error code number otherwise and -1 in case of an internal error.

### xmlSchemaValidatePredefinedType ()

    int	xmlSchemaValidatePredefinedType	(xmlSchemaTypePtr type,
    					 const xmlChar * value,
    					 xmlSchemaValPtr * val)

Check that a value conforms to the lexical space of the predefined type. if true a value is computed and returned in @val.

`type`: | the predefined type
`value`: | the value to check
`val`: | the return computed value
`Returns`: | 0 if this validates, a positive error code number otherwise and -1 in case of internal or API error.

### xmlSchemaValueAppend ()

    int	xmlSchemaValueAppend		(xmlSchemaValPtr prev,
    					 xmlSchemaValPtr cur)

Appends a next sibling to a list of computed values.

`prev`: | the value
`cur`: | the value to be appended
`Returns`: | 0 if succeeded and -1 on API errors.

### xmlSchemaValueGetAsBoolean ()

    int	xmlSchemaValueGetAsBoolean	(xmlSchemaValPtr val)

Accessor for the boolean value of a computed value.

`val`: | the value
`Returns`: | 1 if true and 0 if false, or in case of an error. Hmm.

### xmlSchemaValueGetAsString ()

    const xmlChar *	xmlSchemaValueGetAsString	(xmlSchemaValPtr val)

Accessor for the string value of a computed value.

`val`: | the value
`Returns`: | the string value or NULL if there was none, or on API errors.

### xmlSchemaValueGetNext ()

    xmlSchemaValPtr	xmlSchemaValueGetNext	(xmlSchemaValPtr cur)

Accessor for the next sibling of a list of computed values.

`cur`: | the value
`Returns`: | the next value or NULL if there was none, or on API errors.

### xmlSchemaWhiteSpaceReplace ()

    xmlChar *	xmlSchemaWhiteSpaceReplace	(const xmlChar * value)

Replaces 0xd, 0x9 and 0xa with a space.

`value`: | a value
`Returns`: | the new string or NULL if no change was required.