GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


NAME

       xmerl - Functions for exporting XML data to an external format.

DESCRIPTION

       Functions for exporting XML data to an external format.

EXPORTS

       callbacks(Module) -> Result

              Types:

                 Module = atom()
                 Result = [atom()]

              Find the list of inherited callback modules for a given module.

       export(Content, Callback) -> ExportedFormat

              Equivalent to export(Data, Callback, []).

       export(Content, Callback, RootAttributes) -> ExportedFormat

              Types:

                 Content = [Element]
                 Callback = atom()
                 RootAttributes = [XmlAttributes]

              Exports  normal,  well-formed  XML  content, using the specified
              callback-module.

              Element is any of:

                * #xmlText{}

                * #xmlElement{}

                * #xmlPI{}

                * #xmlComment{}

                * #xmlDecl{}

              (See xmerl.hrl for the record definitions.) Text  in  #xmlText{}
              elements can be deep lists of characters and/or binaries.

              RootAttributes  is  a list of #xmlAttribute{} attributes for the
              #root# element, which implicitly becomes the parent of the given
              Content. The tag-handler function for #root# is thus called with
              the complete exported data of Content. Root  attributes  can  be
              used  to  specify  e.g.  encoding or other metadata of an XML or
              HTML document.

              The Callback module should contain hook functions for  all  tags
              present  in  the  data  structure. A hook function must have the
              following format:

                  Tag(Data, Attributes, Parents, E)

              where E is the corresponding #xmlElement{}, Data is the already-
              exported   contents   of   E  and  Attributes  is  the  list  of
              #xmlAttribute{} records of E. Finally, Parents is  the  list  of
              parent   nodes   of   E,   on   the   form  [{ParentTag::atom(),
              ParentPosition::integer()}].

              The hook function should return either the data to be  exported,
              or  a  tuple {'#xml-alias#', NewTag::atom()}, or a tuple {'#xml-
              redefine#', Content}, where Content is a content list (which can
              be on simple-form; see export_simple/2 for details).

              A  callback  module  can inherit definitions from other callback
              modules, through the required function  '#xml-interitance#()  ->
              [ModuleName::atom()].

              See also: export/2, export_simple/3.

       export_content(Es::Content, Callbacks) -> term()

              Types:

                 Content = [Element]
                 Callback = [atom()]

              Exports normal XML content directly, without further context.

       export_element(E, CB) -> term()

              Exports a normal XML element directly, without further context.

       export_element(E, CallbackModule, CallbackState) -> ExportedFormat

              For  on-the-fly  exporting during parsing (SAX style) of the XML
              document.

       export_simple(Content, Callback) -> ExportedFormat

              Equivalent to export_simple(Content, Callback, []).

       export_simple(Content,    Callback,    RootAttrs::RootAttributes)    ->
       ExportedFormat

              Types:

                 Content = [Element]
                 Callback = atom()
                 RootAttributes = [XmlAttributes]

              Exports "simple-form" XML content, using the specified callback-
              module.

              Element is any of:

                * {Tag, Attributes, Content}

                * {Tag, Content}

                * Tag

                * IOString

                * #xmlText{}

                * #xmlElement{}

                * #xmlPI{}

                * #xmlComment{}

                * #xmlDecl{}

              where

                * Tag = atom()

                * Attributes = [{Name, Value}]

                * Name = atom()

                * Value = IOString | atom() | integer()

              Normal-form XML elements can thus be included in the simple-form
              representation.  Note  that  content  lists  must  be  flat.  An
              IOString  is  a  (possibly  deep)  list  of  characters   and/or
              binaries.

              RootAttributes is a list of:

                * XmlAttributes = #xmlAttribute{}

              See  export/3  for  details  on the callback module and the root
              attributes. The XML-data is  always  converted  to  normal  form
              before being passed to the callback module.

              See also: export/3, export_simple/2.

       export_simple_content(Content, Callback) -> term()

              Exports simple XML content directly, without further context.

       export_simple_element(Content, Callback) -> term()

              Exports a simple XML element directly, without further context.

AUTHORS

       <>

                                  xmerl 1.3.7                      xmerl(3erl)



  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to webmaster@gnu.wiki.
Page load time: 0.085 seconds. Last modified: November 04 2018 12:49:43.