Methods and systems for generating XML documents

Details Methods and systems for generating XML documents Methods and systems for generating XML documents

1999-07-26

2004-01-06

Hong, Stephen S. (Department: 2178)

Data processing: presentation processing of document, operator i

Presentation processing of document

Layout

C715S252000, C715S252000, C709S246000, C709S226000

Reexamination Certificate

active

06675353

ABSTRACT:

TECHNICAL FIELD
This invention relates to methods and systems for generating Extensible Markup Language (XML) documents. More particularly, the invention concerns generating XML documents without building and saving in memory a hierarchical tree structure that represents the XML document.
BACKGROUND
Extensible Markup Language (XML) is a meta-markup language that provides a format for describing structured data. XML is similar to HTML in that it is a tag-based language. By virtue of its tag-based nature, XML defines a strict tree structure or hierarchy. XML is a derivative of Standard Generalized Markup Language (SGML) that provides a uniform method for describing and exchanging structured data in an open, text-based format. XML utilizes the concepts of elements and namespaces. Compared to HTML, which is a display-oriented markup language, XML is a general purpose language for representing structured data without including information that describes how to format the data for display.
XML “elements” are structural constructs that consist of a start tag, an end or close tag, and the information or content that is contained between the tags. A “start tag” is formatted as “<tagname>” and an “end tag” is formatted as “</tagname>”. In an XML document, start and end tags can be nested within other start and end tags. All elements that occur within a particular element must have their start and end tags occur before the end tag of that particular element. This defines a strict tree-like structure. Each element forms a node in this tree, and potentially has “child” or “branch” nodes. The child nodes represent any XML elements that occur between the start and end tags of the “parent” node.
XML accommodates an infinite number of database schemas. Within each schema, a “dictionary” of element names is defined. The dictionary of element names defined by a schema is referred to as a “namespace.” Within an XML document, element names are qualified by namespace identifiers. When qualified by a namespace identifier, a tag name appears in the form “[namespace]:[tagname]”. This model enables the same element name to appear in multiple schemas, or namespaces, and for instances of these duplicate element names to appear in the same XML document without colliding. Start tags can declare an arbitrary number of “attributes” which declare “property values” associated with the element being declared. Attributes are declared within the start tag using the form “<[tagname] [attribute1],[attribute2]. . . , [attributeN]>”, where an attribute1 through attributeN are declarations of an arbitrary number of tag attributes. Each attribute declaration is of the form “[attributeName]=[attributeValue]” where each attribute is identified by a unique name followed by an “=” character, followed by the value of the attribute.
Within an XML document, namespace declarations occur as attributes of start tags. Namespace declarations are of the form “xmlns:[prefix]=[uri]”. A namespace declaration indicates that the XML document contains element names that are defined within a specified namespace or schema. Prefix is an arbitrary designation that will be used later in the XML document as an indication that an element name is a member of the namespace declared by uri. The prefix is valid only within the context of the specific XML document. “Uri” or universal resource indicator is either a path to a document describing a specific namespace or schema or a globally unique identifier of a specific namespace or schema. Uri is valid across all XML documents. Namespace declarations are “inherited”, which means that a namespace declaration applies to the element in which it was declared as well as to all elements contained within that element.
Namespace inheritance within an XML document allows non-qualified names to use “default” namespaces. Default namespaces are explicitly declared as attributes of start tags. Default namespace declarations are of the form “xmlns=[uri]”. Note that the declaration of a default namespace is equivalent to the declaration of a non-default namespace but the prefix is omitted. A namespace specification within an XML document is said to have a “scope” which includes all child nodes beneath the namespace specification.
One exemplary usage of XML is the exchange of data between different entities, such as client and server computers, in the form of requests and responses. A client might generate a request for information or a request for a certain server action, and a server might generate a response to the client that contains the information or confirms whether the certain action has been performed. The contents of these requests and responses are “XML documents”, which are sequences of characters that comply with the specification of XML. In many cases, the process of generating these XML documents involves the building, in memory, of a hierarchical tree structure. Once the hierarchical tree structure is built, in its entirety, the actual XML document in proper syntactic form can then be assembled. Consider the following exemplary XML code:
--<trans:orders
xmlns:person=“http://www.schemas.org/people”
    xmlns:dsig= “http://dsig.org”
xmlns:trans=“http://www.schemas.org/transactions”>
 <trans:order>
  <trans:sold-to>
   <person:name>
    <person:last-name>Layman</person:last-name>
    <person:first-name>Andrew</person:first-name>
   </person:name>
  </trans:sold-to>
  <trans:sold-on>1997-03-17</trans:sold-on>
  <dsig:digital-signature>1234567890</dsig:digital-
signature>
 </trans:order>
</trans:orders>
This code includes three XML namespace declarations that are each designated with “xmlns”. The declarations include a prefix, e.g. “person”, “dsig”, and “trans” respectively, and the expanded namespace to which each prefix refers, e.g. “http://www.schemas.org/people”, “http://dsig.org”, and “http://www.schemas.org/transactions” respectively. This code tells any reader that if an element name begins with “dsig:” its meaning is defined by whoever owns the “http://www.dsig.org” namespace. Similarly, elements beginning with the: “person:” prefix have meanings defined by the “http://www.schemas.org/people” namespace and elements beginning with the “trans” prefix have meanings defined by the “http://www.schemas.org/transactions” namespace. It is important to note that another XML document that incorporated elements from any of the namespaces included in this sample might declare prefixes that are different from those used in this example. As noted earlier, prefixes are arbitrarily defined by the document author and have meaning only within the context of the specific element of the specific document in which they are declared.
Namespaces ensure that element names do not conflict, and clarify who defined which term. They do not give instructions on how to process the elements. Readers still need to know what the elements mean and decide how to process them. Namespaces simply keep the names straight.
FIG. 1
shows how the structure of the above code can be represented in a hierarchical tree structure. In
FIG. 1
, all of the elements or nodes are set out in an exemplary tree that represents the XML document. Such a structure is typically constructed in memory, with each node containing all data necessary for the start and end tags of that node.
It has been typical in the past to build the entire tree structure, such as the one shown in
FIG. 1
, before generating the XML document itself. For large XML documents, this can consume a great deal of memory and processor time. Thus, it would be desirable to avoid this process if at all possible.
Accordingly, this invention arose out of concerns associated with p

Affiliated with

Also associated with

Rating

Methods and systems for generating XML documents does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Methods and systems for generating XML documents, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Methods and systems for generating XML documents will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-3191226