NAME

       xmerl_xsd - Interface module for XML Schema validation.

DESCRIPTION

       Interface  module  for  XML Schema validation. 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 represented 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.30                           xmerl_xsd(3erl)