xmlschemas

xmlschemas —

Synopsis




enum        xmlSchemaValidError;
struct      xmlSchema;
typedef     xmlSchemaPtr;
void        (*xmlSchemaValidityErrorFunc)   (void *ctx,
                                             const char *msg,
                                             ...);
void        (*xmlSchemaValidityWarningFunc) (void *ctx,
                                             const char *msg,
                                             ...);
struct      xmlSchemaParserCtxt;
typedef     xmlSchemaParserCtxtPtr;
struct      xmlSchemaValidCtxt;
typedef     xmlSchemaValidCtxtPtr;
xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt
                                            (const char *URL);
xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt
                                            (const char *buffer,
                                             int size);
void        xmlSchemaFreeParserCtxt         (xmlSchemaParserCtxtPtr ctxt);
void        xmlSchemaSetParserErrors        (xmlSchemaParserCtxtPtr ctxt,
                                             xmlSchemaValidityErrorFunc err,
                                             xmlSchemaValidityWarningFunc warn,
                                             void *ctx);
xmlSchemaPtr xmlSchemaParse                 (xmlSchemaParserCtxtPtr ctxt);
void        xmlSchemaFree                   (xmlSchemaPtr schema);
void        xmlSchemaDump                   (FILE *output,
                                             xmlSchemaPtr schema);
void        xmlSchemaSetValidErrors         (xmlSchemaValidCtxtPtr ctxt,
                                             xmlSchemaValidityErrorFunc err,
                                             xmlSchemaValidityWarningFunc warn,
                                             void *ctx);
xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt (xmlSchemaPtr schema);
void        xmlSchemaFreeValidCtxt          (xmlSchemaValidCtxtPtr ctxt);
int         xmlSchemaValidateDoc            (xmlSchemaValidCtxtPtr ctxt,
                                             xmlDocPtr instance);
int         xmlSchemaValidateStream         (xmlSchemaValidCtxtPtr ctxt,
                                             xmlParserInputBufferPtr input,
                                             xmlCharEncoding enc,
                                             xmlSAXHandlerPtr sax,
                                             void *user_data);

Description

Details

enum xmlSchemaValidError

typedef enum {
    XML_SCHEMAS_ERR_OK		= 0,
    XML_SCHEMAS_ERR_NOROOT	= 1,
    XML_SCHEMAS_ERR_UNDECLAREDELEM,
    XML_SCHEMAS_ERR_NOTTOPLEVEL,
    XML_SCHEMAS_ERR_MISSING,
    XML_SCHEMAS_ERR_WRONGELEM,
    XML_SCHEMAS_ERR_NOTYPE,
    XML_SCHEMAS_ERR_NOROLLBACK,
    XML_SCHEMAS_ERR_ISABSTRACT,
    XML_SCHEMAS_ERR_NOTEMPTY,
    XML_SCHEMAS_ERR_ELEMCONT,
    XML_SCHEMAS_ERR_HAVEDEFAULT,
    XML_SCHEMAS_ERR_NOTNILLABLE,
    XML_SCHEMAS_ERR_EXTRACONTENT,
    XML_SCHEMAS_ERR_INVALIDATTR,
    XML_SCHEMAS_ERR_INVALIDELEM,
    XML_SCHEMAS_ERR_NOTDETERMINIST,
    XML_SCHEMAS_ERR_CONSTRUCT,
    XML_SCHEMAS_ERR_INTERNAL,
    XML_SCHEMAS_ERR_NOTSIMPLE,
    XML_SCHEMAS_ERR_ATTRUNKNOWN,
    XML_SCHEMAS_ERR_ATTRINVALID,
    XML_SCHEMAS_ERR_VALUE,
    XML_SCHEMAS_ERR_FACET,
    XML_SCHEMAS_ERR_,
    XML_SCHEMAS_ERR_XXX
} xmlSchemaValidError;

struct xmlSchema

struct xmlSchema {

    xmlChar *name;        /* schema name */
    xmlChar *targetNamespace;     /* the target namespace */
    xmlChar *version;
    xmlChar *id;
    xmlDocPtr doc;
    xmlSchemaAnnotPtr annot;
    int flags;

    xmlHashTablePtr typeDecl;
    xmlHashTablePtr attrDecl;
    xmlHashTablePtr attrgrpDecl;
    xmlHashTablePtr elemDecl;
    xmlHashTablePtr notaDecl;

    xmlHashTablePtr schemasImports;

    void *_private;	/* unused by the library for users or bindings */
    xmlHashTablePtr groupDecl;
};

xmlSchemaPtr

typedef xmlSchema *xmlSchemaPtr;

xmlSchemaValidityErrorFunc ()

void        (*xmlSchemaValidityErrorFunc)   (void *ctx,
                                             const char *msg,
                                             ...);

`ctx` :
`msg` :
`...` :

xmlSchemaValidityWarningFunc ()

void        (*xmlSchemaValidityWarningFunc) (void *ctx,
                                             const char *msg,
                                             ...);

`ctx` :
`msg` :
`...` :

struct xmlSchemaParserCtxt

struct xmlSchemaParserCtxt;

xmlSchemaParserCtxtPtr

typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;

struct xmlSchemaValidCtxt

struct xmlSchemaValidCtxt;

A Schemas validation context

xmlSchemaValidCtxtPtr

typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;

xmlSchemaNewParserCtxt ()

xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt
                                            (const char *URL);

Create an XML Schemas parse context for that file/resource expected to contain an XML Schemas file.

`URL` :	the location of the schema
Returns :	the parser context or NULL in case of error

xmlSchemaNewMemParserCtxt ()

xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt
                                            (const char *buffer,
                                             int size);

Create an XML Schemas parse context for that memory buffer expected to contain an XML Schemas file.

`buffer` :	a pointer to a char array containing the schemas
`size` :	the size of the array
Returns :	the parser context or NULL in case of error

xmlSchemaFreeParserCtxt ()

void        xmlSchemaFreeParserCtxt         (xmlSchemaParserCtxtPtr ctxt);

Free the resources associated to the schema parser context

ctxt : the schema parser context

xmlSchemaSetParserErrors ()

void        xmlSchemaSetParserErrors        (xmlSchemaParserCtxtPtr ctxt,
                                             xmlSchemaValidityErrorFunc err,
                                             xmlSchemaValidityWarningFunc warn,
                                             void *ctx);

Set the callback functions used to handle errors for a validation context

`ctxt` :	a schema validation context
`err` :	the error callback
`warn` :	the warning callback
`ctx` :	contextual data for the callbacks

xmlSchemaParse ()

xmlSchemaPtr xmlSchemaParse                 (xmlSchemaParserCtxtPtr ctxt);

parse a schema definition resource and build an internal XML Shema struture which can be used to validate instances. *WARNING* this interface is highly subject to change

`ctxt` :	a schema validation context
Returns :	the internal XML Schema structure built from the resource or NULL in case of error

xmlSchemaFree ()

void        xmlSchemaFree                   (xmlSchemaPtr schema);

Deallocate a Schema structure.

schema : a schema structure

xmlSchemaDump ()

void        xmlSchemaDump                   (FILE *output,
                                             xmlSchemaPtr schema);

Dump a Schema structure.

`output` :	the file output
`schema` :	a schema structure

xmlSchemaSetValidErrors ()

void        xmlSchemaSetValidErrors         (xmlSchemaValidCtxtPtr ctxt,
                                             xmlSchemaValidityErrorFunc err,
                                             xmlSchemaValidityWarningFunc warn,
                                             void *ctx);

Set the error and warning callback informations

`ctxt` :	a schema validation context
`err` :	the error function
`warn` :	the warning function
`ctx` :	the functions context

xmlSchemaNewValidCtxt ()

xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt (xmlSchemaPtr schema);

Create an XML Schemas validation context based on the given schema

`schema` :	a precompiled XML Schemas
Returns :	the validation context or NULL in case of error

xmlSchemaFreeValidCtxt ()

void        xmlSchemaFreeValidCtxt          (xmlSchemaValidCtxtPtr ctxt);

Free the resources associated to the schema validation context

ctxt : the schema validation context

xmlSchemaValidateDoc ()

int         xmlSchemaValidateDoc            (xmlSchemaValidCtxtPtr ctxt,
                                             xmlDocPtr instance);

Validate a document tree in memory.

`ctxt` :	a schema validation context
`instance` :
Returns :	0 if the document is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.

xmlSchemaValidateStream ()

int         xmlSchemaValidateStream         (xmlSchemaValidCtxtPtr ctxt,
                                             xmlParserInputBufferPtr input,
                                             xmlCharEncoding enc,
                                             xmlSAXHandlerPtr sax,
                                             void *user_data);

Validate a document tree in memory.

`ctxt` :	a schema validation context
`input` :	the input to use for reading the data
`enc` :	an optional encoding information
`sax` :	a SAX handler for the resulting events
`user_data` :	the context to provide to the SAX handler.
Returns :	0 if the document is schemas valid, a positive error code number otherwise and -1 in case of internal or API error.