Abstract:
An apparatus is provided to map data objects of a data representation language to corresponding objects within a programming language and vice versa. In one embodiment, the apparatus is equipped to receive a mapping definition mapping selected elements of an XML data structure to selected objects of one or more Java classes. The apparatus is further equipped to determine whether the mapping definition comprises one or more definitional statements expressed with XML oriented language elements of a script language. Further, the apparatus is equipped to process the mapping definition statements comprising XML oriented language elements of the script language, in accordance with syntactical and semantic definitions of the XML oriented language elements.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to the field of programming languages. More specifically, the present invention relates to a method for manipulating XML-centric objects in a native programming language environment. 
     2. Background Information 
     XML is rapidly emerging as the de-facto standard for transmitting data structures between software applications and web services. While most software applications and web services are written in modern programming languages, such as Java or C++, none of these programming languages provide native support for representing and manipulating XML. Consequently, programmers are forced to develop or adopt external software packages for representing and manipulating XML within the context of their applications and web services. 
     In general, external software packages are not capable of providing the host language with native support for processing XML data. As such, they represent and manipulate XML in ways that are quite different than those provided by the host language for its native data types. Most often, external software packages represent XML data using a general purpose tree abstraction and provide a tree-based API for navigating and manipulating the data (e.g., getParentNode( ), getChildNodes( ), removeChild( ), etc.). This method of accessing and manipulating data structures is cumbersome and time consuming compared to methods used for accessing and manipulating data structures native to the host programming language. 
     Therefore, a programming language that enables the manipulation of XML data structures with the same power and flexibility afforded native data structures is desirable. 
    
    
     BRIEF DESCRIPTION OF DRAWINGS 
     The present invention will be described by way of exemplary embodiments, but not limitations, illustrated in the accompanying drawings in which like references denote similar elements, and in which: 
     FIG. 1 illustrates an overview of one embodiment of the present invention; 
     FIG. 2 illustrates an exemplary operational flow of interpreter  104 , in accordance with one embodiment of the invention; 
     FIGS. 3A-3C illustrate various exemplary language extensions in accordance with one embodiment of the present invention; 
     FIG. 4 is a block diagram illustrating one embodiment of a communication network suitable for use in practicing the present invention; 
     FIGS. 5A-5B illustrate example functions incorporating language extensions of the present invention for mapping XML documents to Java objects and Java objects to XML documents, in accordance with one embodiment; 
     FIG. 6 illustrates an example computer system suitable for hosting the mapping services of the present invention including interpreter  104 , in accordance with one embodiment; and 
     FIGS. 7A-C illustrate example functions based upon the prior art, for mapping XML documents to Java objects and Java objects to XML documents. 
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
     In the following description, various aspects of the present invention will be described. However, it will be apparent to those skilled in the art that the present invention may be practiced with only some or all aspects of the present invention. For purposes of explanation, specific numbers, materials and configurations are set forth in order to provide a thorough understanding of the present invention. However, it will also be apparent to one skilled in the art that the present invention may be practiced without the specific details. In other instances, well known features are omitted or simplified in order not to obscure the present invention. 
     Parts of the description will be presented in terms of operations performed by a processor based device, using terms such as receiving, analyzing, determining, generating, and the like, consistent with the manner commonly employed by those skilled in the art to convey the substance of their work to others skilled in the art. As well understood by those skilled in the art, the quantities take the form of electrical, magnetic, or optical signals capable of being stored, transferred, combined, and otherwise manipulated through mechanical and electrical components of the processor based device; and the term processor include microprocessors, micro-controllers, digital signal processors, and the like, that are standalone, adjunct or embedded. 
     Various operations will be described as multiple discrete steps in turn, in a manner that is most helpful in understanding the present invention, however, the order of description should not be construed as to imply that these operations are necessarily order dependent. In particular, these operations need not be performed in the order of presentation. Further, the description repeatedly uses the phrase “in one embodiment”, which ordinarily does not refer to the same embodiment, although it may. 
     Overview 
     The present invention includes the provision of functional descriptions in the form of programming language extensions to facilitate flexible manipulation of XML objects in a native programming environment. The language extensions include a native XML data type and a collection of operations that enable programmers to navigate and manipulate XML objects in much the same way native language objects are navigated and manipulated. Accordingly, the present invention provides a mechanism for manipulating both XML and native language objects, that is particularly well suited for the increasingly ubiquitous problem of mapping XML objects into and out of software applications and web services written in modern programming languages. 
     FIG. 1 illustrates an overview of the present invention, in accordance with one embodiment. As shown, mapping services  100  include interpreter/compiler  104  (“interpreter”), which further contains parser  105 . In accordance with the teachings of the present invention, programming statements  102  including various language extensions, are provided to mapping services  100  to be parsed by parser  105 . Once the statements are parsed, interpreter  104  compiles the statements into executable code, which is then provided to execution engine  106 . Execution engine  106  controls execution of the code (by e.g. a processor) as well as performs conventional execution runtime services, such as memory allocation request and release, error/exception handling, and so forth. 
     For the illustrated embodiment, interpreter  104  includes an application programming interface (API) (not shown), through which programming statements formed using language extensions of the present invention, may be programmatically submitted for compilation by a variety of application-specific processes. For example, a web server application may make calls to mapping services  100  upon the receipt of XML documents in order to map the XML document objects as e.g., internal Java classes for additional processing by the web server. Such application-specific processes may be co-resident with mapping services  100  on the same “host” system (not shown) as mapping services  100 , or remotely disposed away from the “host” system and communicate with mapping services  100  using conventional cross system communication techniques. 
     FIG. 2 illustrates an exemplary operational flow of interpreter  104  in accordance with one embodiment of the invention. In operation, interpreter  104  reads a first command of a statement being compiled. As illustrated, upon invocation, at block  202 , interpreter  104  locates the “next” command of the statement being compiled. Locating the “next” command of the statement being compiled may be effectuated using any one of a number of “parsing” techniques known in the art. Upon locating the “next” command of the statement being compiled, at block  204 , interpreter  104  identifies the command read (e.g. from a language dictionary maintained by interpreter  104 ). Next, at block  206 , interpreter  104  reads the rest of the command syntax, and determines the semantic for the identified command. 
     At block  208 , interpreter  104  determines if the end of the statement has been reached. If not, interpreter  104  returns to block  202 , and continues the compilation process from there. Eventually the end of the statement being compiled is reached, and at such time, interpreter  104  may optionally apply one or more optimizations to the commands analyzed, block  210 . The optimizations may be any one or more of the applicable compiler optimization techniques known in the art. 
     Finally, with or without optimizing the commands analyzed, at block  212 , interpreter  104  generates executable code for the commands analyzed. In one embodiment, interpreter  104  generates byte codes for the commands analyzed. In alternate embodiments, other equivalent “code generation” approaches may be practiced instead. 
     Language Mapping Extensions 
     Programming languages do not provide sufficient functionality when it comes to interoperability and translation between XML documents and programming language objects. Therefore, in accordance with the teachings of the present invention, XML-oriented language extensions for use in association with a scripting language, such as Javascript, ECMAScript, and so forth, are provided and will now be described. Although the following language extensions are described in relation to Javascript, the applicability of the present invention should not be read as being limited solely to Javascript. 
     FIGS. 3A-3C illustrate various exemplary Javascript language extensions of the present invention, in accordance with one embodiment. First, language extension  300  illustrates an XML (data) type declaration explicitly indicating that a given variable (e.g. x,y) is associated with an XML class of variables. As illustrated, such XML variables may be declared just as any native Javascript data type may be declared. In one embodiment, a Javascript-aware parser (e.g. parser  105 ) is equipped to recognize XML data type declarations and associate them with the appropriate items in the corresponding symbol table (e.g., variables, function parameters, function return values, etc.). Interpreter  104  uses this type of information to determine the semantics of operations performed on values of type XML, and for example, to decide when to implicitly coerce values to or from-the XML type (described more fully below). In the illustrated embodiment, the XML type is declared by way of a self-identifying prefix (e.g., ‘XML’). 
     Language extension  310  illustrates an assignment made between a structured expression including XML syntax and an XML-typed variable. For example, in line  310 (A) an XML-typed variable “p” is assigned an XML structure representing a person element including name (e.g. John) and age (e.g.  25 ) elements. Although the expression in line  310 (A) includes an explicit XML-type indicator (as described above), in accordance with one embodiment of the invention, variables initialized using expressions containing XML syntax do not require such explicit XML-type declarations. In one embodiment, the “&lt;” symbol, which is used in all XML tag definitions, is further utilized in the present invention as a unary operator to indicate to the interpreter that the expression to follow is to be treated as a string, and parsed as an XML statement. In one embodiment, the operand of the “&lt;” operator is the entire XML literal up to and including the end tag. Accordingly, since the unary operator “&lt;” triggers a result in a value of type XML, it is not necessary for variables being assigned XML literals to be explicitly declared as type XML. For example, lines  310  (B)-(E) illustrate an XML-type variable “e” that has been implicitly declared based upon the content of the expression. 
     Language extension  320  illustrates that, in accordance with the teachings of the present invention, portions of an XML literal can be determined dynamically through the use of embedded expressions. In the illustrated embodiment, the mapping services of the present invention dynamically resolve portions of XML literals containing embedded Javascript expressions. In one embodiment, interpreter  104  is equipped to recognize a set of curly braces (e.g., “{. . . }”) as an embedded expression operator having higher precedence than the unary operator “&lt;” (described above). However, it should be noted that operators other than “{ }” may be utilized as an embedded expression operator without departing from the spirit and scope of the invention. In any event, if parser  105  identifies that the embedded expression operator is present within an expression, the operand enclosed within the operator is passed to interpreter  104  for evaluation, with the resulting return value being coerced (described below) to type string. Thereafter, string concatenation is used to insert the return value between the preceding and following XML literals. Once all the embedded expressions have been evaluated and their results inserted within the XML literal, the presence of the “&lt;” operator causes interpreter  104  to convert the resulting string to an XML type. 
     Language extension  330  illustrates the principle of type coercion practiced by interpreter  104 . In accordance with one embodiment of the invention, any value of type string that occurs where parser  105  expects a value of type XML is automatically converted to the XML data type by parsing the contents of the string as XML. Prior to the conversion, the string value can be constructed and manipulated using string arithmetic without regard for XML constraints such as well-formedness. For example, in lines  330 (A)-(D) of FIG. 3B, an XML type variable is assigned the result of multiple string concatenations. More specifically, the variable “tagName” of type string is concatenated with two other string values (e.g., “&lt;” and “&gt;”)to form XML open and close tags. The resulting tags are again treated as strings and concatenated with the values of “john” and “Sue”, which are also treated as strings notwithstanding the fact that they represent XML expressions. The resulting string value is then coerced back into an XML value due to the explicit “XML” data type declaration. Additionally, string values are also automatically coerced into XML values in other contexts where XML is expected. For example, string values passed to functions expecting XML parameters and string values embedded within XML literals will similarly be converted into XML. Accordingly, line  330 (E) yields the same result as line  330 (D). 
     Language extensions  340  illustrate the principal that once a variable contains an XML value, the child elements of the XML variable may be accessed and/or assigned using a predefined operator such as, but not limited to a period/dot (“.”) (hereinafter “dot operator”). The dot operator examines all of the child elements of its left operand and returns in order, those elements with names that match the right operand. This may result in zero or more elements being returned. In one embodiment, if the designated child element is a leaf node, then the content of the child element is returned. However, if the designated child element is not a leaf node, then the designated child element complete with all of its descendants is returned (see e.g.  340 (D)). Additionally, it is possible for the left operand of a dot operator to be a list of elements instead of a single element (e.g., consider when two or more dots are used in succession). In this case, the dot operator iterates over the list examining the children of each element in order. This treatment intentionally blurs the distinction between a single element and lists of elements to simplify the programmer&#39;s task. 
     Language extension  350 , illustrates that attributes of an XML element may be accessed and assigned using an “attribute” operator. In one embodiment, the attribute operator is represented by the ‘.@’ symbol. The attribute operator examines all of the attributes of its left operand and returns the value of the one whose name matches its right operand. For example, in line  350 (A), the value associated with the ‘id’ attribute for one of at least two employees is retrieved and assigned to an ‘empid’ variable of type integer. 
     In addition to providing direct access to the immediate child elements of an XML value, the language extensions of the present invention provide direct access to all descendents (i.e., children, grandchildren, great grandchildren, etc.) of an XML value (see e.g., language element  330 ). In one embodiment the “double dot” (e.g. ‘..’) operator examines all of the descendent elements of its left operand and returns those with names that match its right operand in document order. When the left operand is a list of elements, the “..” operator iterates over the list examining the descendents of each element in order. 
     Language extension  370  illustrates an indexing property of the present invention, whereby given a list of child elements, a predefined indexing operator may be utilized to identify an individual child element within the list. In one embodiment, a set of square brackets “[ ]” is used as the indexing operator. The indexing operator essentially selects a single element from its left operand based on its ordinal position within the list. The left operand may represent a list of elements, or a single element. In the event the operand represents a single element, it will be treated as a list having a size equal to one. 
     The present invention also provides for iterating over lists of child elements as illustrated by language element  380 . In the illustrated example, the expression “e..name” returns a list of elements, and the “for” statement steps through the list in order. For each element in the list, the “for” statement assigns the variable “n” to the element and executes the code nested in the curly braces. Alternatively, the length of a list of child elements may be determined using the same methods available in the host programming language to determine the length of an array. For example, in the statement on line  380 (C)), the length of the list of child elements is determined by accessing the implicit “length” property (e.g., “.length”) of the host ECMAScript language. Accordingly, lines  380 (C)-(D) produce the same result as will be produced by lines  380 (A)-(B). 
     Example Application 
     As alluded to above, the language extensions of the present invention are particularly well-suited for use in mapping objects from a data representation language to corresponding objects of a programming language, and vice versa. Such a language mapping may be desirable in situations where, for example, a system having an internal operating environment based upon a programming language such as Java, is required to exchange data with other systems using a data representation language such as XML. 
     FIG. 4 is a block diagram illustrating an exemplary communication network incorporating the teachings of the present invention. As shown, service provider  405 , client  110 , and end users  415  are communicatively coupled together by network  402 . Network  402  represents any of a number of communication networks such as one or more local area networks, wide area networks, the Internet, and so forth. Service provider  405  represents a “value added” service provider that provides content and/or services to client  410  and end users  415 . Client  410  represents one or more entities that utilize the value added services of service provider  405  in order e.g., to provide improved content to end users  415  over network  402 . 
     Assume, for example, that service provider  405  has developed a new web service for generating interactive geographic maps that highlight various points of interest on behalf of client  410 . To take advantage of this service offered by service provider  405 , client  410  transmits a list of points of interest to service provider  405  via network  402 . In response, service provider  405  generates one or more interactive geographic maps, which display selectable representations of the points of interest provided by client  410 . Service provider  405  then returns one or more URL(s) pointing to the geographic map(s) to client  410 , which in turn utilizes the URL(s) to display the geographic map(s) to end users  415 . Each time a geographic map is presented to end users  415  by client  410 , end users  415  may select one or more of the points, which are then returned to service provider  405 . Service provider  405  then transmits the selected points back to the client  410  for any further processing client  410  wishes to perform. 
     The nature of the processing client  410  may perform is determined by client  410  and depends e.g. upon the context in which the service provider&#39;s services are utilized. For example, client  410  may represent a real estate agency that uses the points to display demographic data and property locations to end users  415 , a weather service that uses the points to graphically display temperatures and weather phenomenon the weather service has gathered, a product manufacturer that uses the points to graphically display store locations, and so forth. 
     Each such incarnation of client  410  may utilize their own pre-defined XML format for transmitting such points of interest. For example, the weather community may have agreed on a format for transmitting information about weather phenomenon, the real estate community may have agreed on a format for transmitting information about homes, and product manufactures may have agreed on a format for transmitting store locations. The following Example 1 shows an XML format used e.g. by the product manufacturing community for transmitting the locations of stores that carry their products. . . . 
     
       
         
               
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 Example 1: 
                 &lt;available-at&gt; 
               
             
          
           
               
                   
                 &lt;store&gt; 
               
             
          
           
               
                   
                 &lt;name&gt;The Electronics Store&lt;/name&gt; 
               
               
                   
                 &lt;address&gt; 
               
             
          
           
               
                   
                 &lt;street&gt;23 Transistor Dr.&lt;/street&gt; 
               
               
                   
                 &lt;city&gt;Circuit&lt;/city&gt; 
               
               
                   
                 &lt;state&gt;WA&lt;/state&gt; 
               
               
                   
                 &lt;zip&gt;12345&lt;/zip&gt; 
               
             
          
           
               
                   
                 &lt;/address&gt; 
               
             
          
           
               
                   
                 &lt;/store&gt; 
               
               
                   
                 &lt;store&gt; . . . &lt;/store&gt; 
               
               
                   
                 &lt;store&gt; . . . &lt;/store&gt; 
               
             
          
           
               
                   
                 &lt;/available-at&gt; 
               
               
                   
                   
               
             
          
         
       
     
     Internally, however, service provider  405  represents points of interest as an array of points, each defined by the Java class shown below in Example 2. . . . 
     Example 2 
     public class Point { 
     String label; //text to display next to point 
     LatitudeLongitude location;//location of point on map 
     } 
     In order to make it easy for a broad range of client communities to access their service, service provider  405  would like to be able to accept data in a wide variety of XML formats (i.e. such as the one shown in Example 1), and then have that data automatically mapped into analogous data structures within the native programming language of service provider  405 . 
     FIGS. 5A-5B illustrate example functions, incorporating language extensions of one embodiment of the present invention for mapping XML documents to Java objects and Java objects to XML documents, as described above with respect to FIG.  4 . In the illustrated example, service provider  405  would call the “FromXML” function (as shown in FIG. 5A) each time it received an XML document from client  410  that needed to be converted into Java objects. Similarly, each time service provider  405  needed to translate internal java objects into XML for use by client  410 , service provider  405  would call the “ToXML” function of FIG.  5 B. 
     Reference is now drawn to FIG. 5A within which the “FromXML” function is illustrated. Assume a new client is in the process of transmitting location data to service provider  405  in the form of an XML document containing the structure shown in Example 1. Upon receiving the data, service provider  405  will initiate a function call to “FromXML”. Among items to note within the function, statement  500  uses the “double dot” operator (described above), in addition to the “.length” instruction to navigate through the received XML structure and allocate one new point object for each XML address provided. Next, for each address provided in the XML data, a display label and point location are determined based upon the internal data constraints of service provider  405  (as shown in Example 2). In statement  505 , the “availableat..address” returns a list of address elements, which in turn are iteratively assigned to the variable “a”. Next, the name of each store is determined using the built-in parents function followed by the dot operator. In addition, the street address, city, state, and zip within which that store is located, is determined using the dot operator. As is illustrated by statements  510 , strings returned by the direct access of descendent address elements are concatenated together to form the point label. Additionally, address information, including street, city, state, and zip information, is used in a LatitudeLongitude function (not shown) that computes a map location given an input address. 
     In FIG. 5B, a “ToXML” function is illustrated for use in converting Java based point locations into the XML elements shown in Example 1. To begin, the root node “&lt;available-at&gt;” is constructed by statement  525  using an XML literal. Next, statements  530  use a “String.split( )” function to parse the display label to determine a store name, street address, city, state and zip for each point. Finally, statements  535  create a store element for each point, which are appended to the root node from statement  525 . 
     FIGS.  7 AC illustrate example functions for mapping XML documents to Java objects and Java objects to XML documents, based upon conventional applications and techniques known in the prior art. As it can be readily seen, the amount and complexity of code required to implement the above-illustrated functions using Java and the standard XML Document Object Model (DOM) is substantial. However, in comparison, given the teachings of the present invention including the previously described language extensions, such an effort may be minimized considerably. 
     Example Host Computer System 
     FIG. 6 illustrates an example computer system suitable for hosting mapping services  100  and interpreter  104  of the present invention. As shown, computer system  600  includes one or more processors  602 , and system memory  604 . Additionally, computer system  600  includes mass storage devices  606  (such as diskette, hard drive, CDROM and so forth), input/output devices  608  (such as keyboard, cursor control and so forth) and communication interfaces  610  (such as network interface cards, modems and so forth). The elements are coupled to each other via system bus  612 , which represents one or more buses. In the case of multiple buses, they are bridged by one or more bus bridges (not shown). Each of these elements performs its conventional functions known in the art. In particular, system memory  604  and mass storage  606  are employed to store a working copy and a permanent copy of the programming instructions implementing the interpreter and/or mapping services of the present invention. The permanent copy of the programming instructions may be loaded into mass storage  606  in the factory, or in the field, through e.g. a distribution medium (not shown) or through communication interface  610  (from a distribution server (not shown). The constitution of these elements  602 - 612  are known, and accordingly will not be further described. 
     Conclusion and Epilogue 
     Thus, it can be seen from the above descriptions, novel XML extensions to a script based language have been described. The novel scheme is particularly useful for mapping data objects between a programming language and a data representation language. While the present invention has been described referencing the illustrated and above enumerated embodiments, the present invention is not limited to these described embodiments. Numerous modification and alterations may be made, consistent with the scope of the present invention as set forth in the claims to follow. Thus, the above-described embodiments are merely illustrative, and not restrictive on the present invention.