xmlschemastypes: implementation of XML Schema Datatypes

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

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.