NAME

       xmerl_xsd - Interface module for XML Schema vlidation.

DESCRIPTION

       Interface  module  for  XML  Schema  vlidation. It handles the W3.org specifications of XML Schema second
       edition 28 october 2004. For an introduction to XML Schema study part 0. An XML structure is validated by
       xmerl_xsd:validate/[2,3].

DATA TYPES

         filename() = string():

         global_state():

           The global state of the validator. It is representated by the #xsd_state{} record.

         option_list():

           Options allow to customize the behaviour of the validation.

           Possible options are :

           {tab2file,boolean()}:
             Enables saving of abstract structure on file for debugging purpose.

           {xsdbase,filename()}:
             XSD Base directory.

           {fetch_fun,FetchFun}:
             Call back function to fetch an external resource.

           {fetch_path,PathList}:
             PathList  is a list of directories to search when fetching files. If the file in question is not in
             the fetch_path, the URI will be used as a file name.

           {state,State}:
             It is possible by this option  to  provide  a  state  with  process  information  from  an  earlier
             validation.

EXPORTS

       file2state(FileName) -> {ok, State} | {error, Reason}

              Types:

                 State = global_state()
                 FileName = string()

              Reads  the  schema  state  with  all  information of the processed schema from a file created with
              state2file/[1,2]. The format of this file is internal. The state can then be  used  validating  an
              XML document.

       format_error(L::Errors) -> Result

              Types:

                 Errors = tuple() | [tuple()]
                 Result = string() | [string()]

              Formats error descriptions to human readable strings.

       process_schema(Schema) -> Result

              Equivalent to process_schema(Schema, []).

       process_schema(Schema, Options) -> Result

              Types:

                 Schema = string()
                 Result = {ok, State} | {error, Reason}
                 State = global_state()
                 Reason = [ErrorReason] | ErrorReason
                 Options = option_list()

              Reads  the  referenced  XML  schema  and  checks that it is valid. Returns the global_state() with
              schema info or an error reason. The error reason may be a list of several errors or a single error
              encountered during the processing.

       process_schemas(Schemas) -> Result

              Equivalent to process_schema(Schemas, []).

       process_schemas(Schemas, Options) -> Result

              Types:

                 Schemas = [{NameSpace, string()} | Schemas] | []
                 Result = {ok, State} | {error, Reason}
                 Reason = [ErrorReason] | ErrorReason
                 Options = option_list()

              Reads  the  referenced  XML  schemas  and controls they are valid. Returns the global_state() with
              schema info or an error reason. The error reason may be a list of several errors or a single error
              encountered during the processing.

       process_validate(Schema, Xml::Element) -> Result

              Equivalent to process_validate(Schema, Xml, []).

       process_validate(Schema, Xml::Element, Opts::Options) -> Result

              Types:

                 Schema = string()
                 Element = XmlElement
                 Options = option_list()
                 Result = {ValidXmlElement, State} | {error, Reason}
                 Reason = [ErrorReason] | ErrorReason

              Validates a parsed well-formed XML element towards an XML schema.

              Validates in two steps. First it processes the schema, saves the type and structure info in an ets
              table and then validates the element towards the schema.

              Usage example:

              1>{E,_} = xmerl_scan:file("my_XML_document.xml").
              2>{E2,_} = xmerl_xsd:validate("my_XML_Schema.xsd",E).

              Observe that E2  may  differ  from  E  if  for  instance  there  are  default  values  defined  in
              my_XML_Schema.xsd.

       state2file(S::State) -> ok | {error, Reason}

              Same as state2file(State,SchemaName)

              The name of the saved file is the same as the name of the schema, but with .xss extension.

       state2file(S::State, FileName) -> ok | {error, Reason}

              Types:

                 State = global_state()
                 FileName = string()

              Saves the schema state with all information of the processed schema in a file. You can provide the
              file name for the saved state. FileName is saved with the .xss extension added.

       validate(Xml::Element, State) -> Result

              Equivalent to validate(Element, State, []).

       validate(Xml::Element, State, Opts::Options) -> Result

              Types:

                 Element = XmlElement
                 Options = option_list()
                 Result = {ValidElement, global_state()} | {error, Reasons}
                 ValidElement = XmlElement
                 State = global_state()
                 Reasons = [ErrorReason] | ErrorReason

              Validates a parsed well-formed XML element (Element).

              A call to validate/2 or validate/3 must provide a well formed parsed XML element #xmlElement{} and
              a  State, global_state(), which holds necessary information from an already processed schema. Thus
              validate enables reuse of the schema information and therefore if one shall validate several times
              towards the same schema it reduces time consumption.

              The  result,  ValidElement,  is  the  valid  element  that  conforms to the post-schema-validation
              infoset. When the validator finds an error it tries to continue and reports a list of  all  errors
              found. In those cases an unexpected error is found it may cause a single error reason.

              Usage example:

              1>{E,_} = xmerl_scan:file("my_XML_document.xml").
              2>{ok,S} = xmerl_xsd:process_schema("my_XML_Schema.xsd").
              3>{E2,_} = xmerl_xsd:validate(E,S).

              Observe  that  E2  may  differ  from  E  if  for  instance  there  are  default  values defined in
              my_XML_Schema.xsd.

AUTHORS

       <>

                                                  xmerl 1.3.16                                   xmerl_xsd(3erl)