WO2004068292A2 - Xml types in java - Google Patents
Xml types in java Download PDFInfo
- Publication number
- WO2004068292A2 WO2004068292A2 PCT/US2004/001827 US2004001827W WO2004068292A2 WO 2004068292 A2 WO2004068292 A2 WO 2004068292A2 US 2004001827 W US2004001827 W US 2004001827W WO 2004068292 A2 WO2004068292 A2 WO 2004068292A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- xml
- type
- java
- data
- types
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/51—Source to source
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/80—Information retrieval; Database structures therefor; File system structures therefor of semi-structured data, e.g. markup language structured data such as SGML, XML or HTML
- G06F16/84—Mapping; Conversion
- G06F16/86—Mapping to a database
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
Definitions
- the invention relates to the transformation of data and data types.
- Figure 1 illustrates an exemplary XML schema definition file that can be used in accordance with embodiments of the present invention.
- Figure 2 is a diagram of an exemplary system for XML marshaling and unmarshaling that can be used in accordance with embodiments of the present invention.
- Figure 3 illustrates exemplary code representing the XML types compiled from an XML schema that can be used in accordance with embodiments of the present invention.
- Figure 4 illustrates exemplary code of an annotation-based format that can be used in accordance with embodiments of the present invention.
- Figure 5 illustrates exemplary code implementing a Web service that can be used in accordance with embodiments of the present invention.
- Figure 6 illustrates exemplary code for type transformation that can be used in accordance with embodiments of the present invention.
- Figure 7 illustrates exemplary code for default type declaration that can be used in accordance with embodiments of the present invention.
- Figure 8 illustrates exemplary code for XML transformation that can be used in accordance with embodiments of the present invention.
- Figure 9 illustrates exemplary code for XML transformation that can be used in accordance with embodiments of the present invention.
- Figure 10 is a diagram of an exemplary XML transformation system that can be used in accordance with embodiments of the present invention.
- Figure 11 is a diagram of an exemplary system for XML store that can be used in accordance with embodiments of the present invention.
- Figure 12 is a diagram of an exemplary system for XML schemas that can be used in accordance with embodiments of the present invention.
- Figure 13 is a diagram of an exemplary system for XML types that can be used in accordance with embodiments of the present invention.
- Figure 14 is a diagram showing an exemplary hierarchy diagram that can be used in accordance with embodiments of the present invention.
- Systems and methods in accordance with one embodiment of the present invention overcome many deficiencies in existing marshaling and unmarshaling systems by translating XML schemas, which define XML data in an XML document, into XML types in Java when marshaling data between XML and Java.
- XML types are actually Java types which, in addition to regular Java bean functions and access to database, can also access and update XML data within Java in an efficient, type-safe, robust, and convenient way.
- An architecture can be used in at least one embodiment that provides the ability to handle almost 100% of the schema introduced by a user.
- the use of XML types can allow the combination of XML- and Java-type systems. This can be done in a way that allows developers to achieve loose coupling.
- XML schemas realized as XML types can remain fully faithful to the XML. It can be easy for a developer to take control of precise transformations between existing Java types and existing XML types.
- XML types can address the Java/XML boundary by bringing together several technologies, including for example schema-aware strongly typed access to XML data document from Java, compact and indexed in-memory XML store, speedy and minimal (pull) parsing and (binary) serialization, lightweight document-cursor traversal, XPath and XQuery navigation and transformation, and seamless Java IDE integration
- Figure 1 shows a simple exemplary XML schema definition (XSD) file that can be used with embodiments of the present invention.
- XSD XML schema definition
- This particular XML schema describes the type of a purchase order.
- the schema can be a pre-existing file that was generated by a schema tool or created by a user. In this example, it may be necessary to "clean up” or "fix” invalid XML purchase order information.
- XSD At the top of the XSD is a schema definition for an element named 'purchase order.' The element is defined as a complex type and contains an element called "line- item.” There is a 'maxOccurs' attribute set to 'unbounded,' meaning that the line-item can be repeated any number of times. Each of the line items is shown to have four sub- elements: desc, itemid, price, and qty.
- the 'desc' sub-element refers to a description element which is a string
- 'itemid' refers to an item identifier element which is an integer (type int)
- 'price' refers to a price element which is a floating point number (type float)
- 'qty' refers to a quantity element which is an integer.
- an XML schema file can be added to a Java project.
- An example of a system for XML marshaling and unmarshaling is shown in Figure 2.
- the system can process the file with a compiler 100 that knows not only how to compile a Java project 101, but also is capable of compiling the XSD file 102.
- a compiler 100 that knows not only how to compile a Java project 101, but also is capable of compiling the XSD file 102.
- XSD file When XSD file is compiled, a number of XML types 103 can be generated in addition to regular Java types 104. These XML types can then be added to the classpath. For example, an XML type called "purchase order" can be generated from the schema type called "purchase-order.”
- FIG. 3 A Java source code representation of the XML types compiled from the example schema in Figure 1 is shown in Figure 3, where the source that generates these Java types is the schema file itself.
- a type called Lineltem corresponds to the line item- element nested inside the purchase-order element in the XSD file.
- the XML line-item element can turn into something similar.
- a Java field can be generated for each element inside a type.
- For the "desc" element in the XSD for instance, there are corresponding "getDesc” and "setDesc” methods in the generated type for each line item.
- the names of the generated types can be automatically derived from the schema names .
- Each generated type can be annotated with the relevant schema name from which it comes.
- Each type can also extend an existing XML type.
- XML types can implement a common base XML type called "XMLObject".
- XMLObject Such an XML type provides the ability to execute a number of XML-oriented data manipulations and will be referred to herein as an "XBean".
- An XBean is not a standard Java bean, as an XBean inherits from an XMLObject.
- An XMLObject is unusual, in that an XMLObject as an XML type provides a way for each XBean to retrieve its original, or corresponding, XML.
- An XBean can be thought of as a design pattern for Java types representing data, such as business data, that can be serialized and de-serialized to XML, as well as accessed in a type-safe way from Java.
- XBeans can also be thought of as a small set of natural language idioms, either annotated Java or non-Java, for generating those types.
- XBeans in one embodiment can sit at the intersection of three types of business data: XML data 105, Java data 106, and database 107.
- An XBean can simply contain data, without any logic or means for communication or computation.
- An XBean can be defined using any of a number of idioms. Once an XBean is defined, the XBean can be used in various contexts.
- an XBean can be defined using XML schema, then instantiated by attaching the XBean to an XML input stream.
- the Java types that are generated can be passed around and used as a Java bean, with friendly getters and setters.
- a user might have cared whether a name came before a description or a description came before a name.
- Systems and methods in accordance with the present invention allow a user to get back to the original, ordered XML.
- An XML type can have a number of XML data operations, including methods to query values using XPath, transform values using XQuery, or iterate over the data document using an XMLCursor . This base type can hold several technologies together.
- XML types can be used to implement a Web service that executed the requested operation such as shown in Figure 5.
- the exemplary code in this Figure can be used to fix quantities in an entire purchase order.
- the method is declared as a Web service operation that takes a PurchaseOrder XML type.
- the Web services runtime can recognize XML types and pass incoming messages efficiently, without fully parsing the XML.
- the other XML type that was declared in the schema is Lineltem, which can be seen on lines 4, 5, and 7 as an array called emptyltems.
- compiled XML types are strongly typed, they allow validation of both schema, such as validating PurchaseOrder against a schema file, and Java compiler checking, such as verifying that the type of the argument of emptyItems[i].setQty(l) is an integer.
- a user might receive a number of purchase orders with high line items that have erroneously set the line item with quantity 0. That user may wish to manipulate these purchase orders, such that whenever somebody leaves a quantity field set to 0, the system changes that quantity field to 1.
- a function can take a purchase order XBean as input, and an XPath can be executed on the purchase order which looks for any line item tags underneath the purchase order tag that have quantity equal to 0. This is shown, for example, starting at line 5 in the Figure.
- a list of nodes can be returned to the user that match the XPath. That list of nodes can be cast back to the XBean type that the user knows it to be.
- the system selects a set of line items that can be cast to an array. Once the results are obtained from XPath, it is possible to iterate through the results and use an XBean method to manipulate the result nodes.
- XML types can extend a base XML-oriented XMLObject type that provides, for example, XPath, XQuery, XMLCursor, and XMLReader.
- the Lineltem types can be used to update the XML data document.
- Each instance of the type refers to a specific node in the document, and when methods such as setQty(l) are called, the data of the document are being manipulated in an easy, type-safe way.
- the type is returned directly from the Web service to complete the function and send the response message.
- Systems and methods in accordance with embodiments of the present invention can also deal with transformation among different XML types, where a user may need to process an XBean to retrieve data. For example, it may be necessary to clean up the line items by modifying the description and price to match the item ID. This can be done in one example by looking up each catalog item in an existing application database. This work can be done using a Java lookup method that can take an integer item id and return a Catalogltem type. For instance:
- catalogID rather than an "itemlD.”
- Catalogltem is so similar to Lineltem, it may be desirable in some situations to write code such as that shown in Figure 6.
- the value of a complex XML type, Lineltems is being set to a complex Java type, Catalogltem.
- Each XML type has a set method that can take an arbitrary type, such that the above code can compile and run.
- the user can get an XML conversion exception, complaining "No Transformation has been defined mapping from Catalogltem to Lineltem”.
- the user can select the appropriate Catalogltem type name and check the corresponding XML transformation.
- each XML transformation can be implemented using an XQuery stored in a directory of transformations.
- Each XQuery can transform from one or more types, each with a known XML schema, into a specific type.
- a visual XQuery editor can be used that has input and output types pinned to the line-item type, as well as the default type for Catalogltem.
- An XQuery editor can allow a system or user to connect itemlD to catalogID, and to indicate that the quantity should be zero.
- FIG 7. An example of a default type declaration for the Catalogltem class is shown in Figure 7. It can be visually written by XQuery into a file in a directory that contains all the transformations.
- An XQuery can be defined that tells the system how to transform a catalog item into a regular line item.
- An example of such a query is shown in Figure 8.
- the bolded text in Figure 8 corresponds to an XQuery that maps catalogID into itemid and sets the extra field qty to 0.
- the remainder is an envelope that holds the XQuery in an XML file.
- This 0 value can be corrected, such as can be done in Java as shown in Figure 9.
- exemplary code can be seen where the catalog item is being sent into the items line. It can be desirable to take a catalog item that a user is getting from an existing API and get that item into an XBean that will represent a line item. Such code would not normally work, as the catalog item is different from the line item.
- FIG. 10 An example of an XML transformation system is shown in Figure 10.
- a global registry of transformations(XQueries) 111 can be used to get from one data type to another. Once a set of XQueries is obtained, the transformation system 110 can automatically look up whether a transformation exists from a source type 108 to a target type 109.
- a library of transformations 112 can still be used, but instead of automatically transforming from a source type to a destination type, each transformation will be given a name. When a catalog item is given and a regular line item needs to be set, for example, the user can simply invoke the transformation by name before the set is called.
- An alternative way to ensure that the quantity is correct is to define the Catalogltem through a line-item transformation to take two input arguments, such as a Catalogltem and an integer quantity.
- a line-item transformation to take two input arguments, such as a Catalogltem and an integer quantity.
- Sources and targets are allowed to be Java types. Whenever an automatic translation between two different types is required, the registry can be consulted.
- a registry can be used that allows a single Java type to map to any number of different XML types, depending on the situation.
- a registry can also have the advantage that every mapping between any two given types need only be defined once, and then it is easily reusable.
- a user may wish to write a Web service that takes a catalog item as input, or to expose an existing Java function such as "findCatalogltem” as a Web service.
- findCatalogltem an existing Java function
- the following code could be written to expose findCatalogltem as a Web service in existing systems: class MyWebService
- This embodiment provides for the association of an XQuery with an XML Map, the support of every schema, and a way to get simultaneous access to both the strongly-typed view and the XML view of the data.
- XML type can be loaded into a lightweight internal XML store 115.
- This is similar to what can be done with the W3C Document Object Model (DOM), but is done in a more lightweight way, which can have complete fidelity to the original XML.
- the store is lightweight, since it only retains the XML data 113 either as a searchable index, or as in the current example, at approximately the text or tag level.
- a user with a strongly-typed Java can begin to add new line items or to change quantities, for example. If that user then wants to run an XPath path on the Java type, the Xpath may need to be run on the XML data document in the current form of the data. In this case, if a user makes a modification to a document, either on the XML side or on the strongly-typed Java side, the appropriate portion of the other side can be invalidated. When a user subsequently looks at that other side, the previously-invalidated information can be faulted in.
- XML schema In order to compile an XML schema, it can be necessary to parse the schema, or XSD file, which is referred to as "schema for schema", In other words, an XSD file that represents the appropriate schema for the XSD files themselves. If a system is supposed to be able to handle 100% of the schema passed to the system, and the system generates convenient Java accessibility, it can be expected that the system uses its own generated types for understanding XSD files when the system reads schema. A user should be able to take the schema for schema and compile that into Java, such that the system can simply use the Java.
- the legal type of the data defines what kind of data is regarded as valid for the current application.
- a schema can contain very specific details regarding the legal types of data, and can in some instances contain some detail regarding the meaning of the data.
- Once the legal type of the data is known it is possible to generate an automatic type that provides access to that data in a strongly-typed way. This is possible in part because the schema can identify all the valid sub-fields of a given data field. It is then possible to grant a user strongly- typed Java access in the appropriate place(s).
- a schema compiler 117 can be used that understands the raw data. This is somewhat similar to what are known as compiler compilers, such as YACC ("Yet Another Compiler Compiler”), which are capable of taking an abstract grammar and compiling the abstract grammar into a syntax tree. Since XML is already a syntax tree, this is not a problem. XML is not, however, a constrained syntax tree. Any node can have a variety of elements beneath it in the tree. Once a user has a schema, which can be thought of as a grammar for XML, the user knows exactly what is supposed to be underneath any given node. Therefore, instead of using just a raw XML syntax tree, a user can take advantage of a schema-constrained syntax tree.
- Systems and methods in accordance with one embodiment of the invention maintain each schema as a Java type, including simple types. If a user has a schema that is a restriction of a simple type, it can be indicated in the schema. For instance, if a user- defined type to be an integer of a legal type, it has to be a five digit number between 10,000 - 99,000. It is not necessarily desirable to define this to be a simple integer type as in existing systems. Instead, the information can be generated into a Java type. The name of the Java type can then be generated from the schema, such as the name "restricted integer.”
- Another invariant that can be maintained by systems and methods in accordance with the present invention arises in cases where there are at least two types in a schema that are base types. If one of the types is a base type of the other, that relationship will connect the two types in Java. A high-fidelity translation of typed systems can allow base types to be preserved.
- a validation engine using complied XML type constraints 118 can also be used to allow a user to determine whether any relevant XML type 120 is valid according to the XML.
- a purchase order line item might have a description quantity, catalog number, and a price.
- Java there is no way of indicating that a field is not optional, or cannot be null. As such, most people who do marshaling are not able to validate a bean.
- Validate methods in accordance with embodiments of the present invention can be used that allow a use to validate any bean against the XML type constraints, and to be informed of any validity problems.
- an XML type can be shared among multiple Java components.
- An XBean can be automatically emitted, such as where an automatically generated XML type is defined for a user- defined component works.
- XBeans representing parameters and return values can be auto-generated as inner classes to an XML control interface generated for the component. If the message types are actually shared across many components, it may not make sense to have private XBean types for each instance of the message. In such case, it should be possible to refer to an XBean type explicitly when defining a user- defined component, in order to explicitly control how the XML type of the component is shaped. For example: package mypackage;
- a generated XML control interface that can be obtained when specifying explicit XBeans on the component can be as follows: package mypackage; interface MyComponentXMLControl
- the named XBean types are used to specify the xml schemas allowed, and there are no generated inner classes.
- An XBean type can extend a base XML type, such that wherever XML can be passed, an XBean can be passed as well. In addition, any XBean can be attached to an
- XBeans can be created easily and used in several different ways. For instance, an XBean can be created implicitly via the definition of a JWS (Java Web services) method. An XBean can be created based on a parameter list of the function and the maps associated with the function. Also, an XBean can be created explicitly using a *.xbean file. A *.xbean file can have at least two different implementations, such as
- JavaBean+Maps or XML+Query each of which can freely use annotations.
- An example of implicitly creating a bean over a JWS operation might look like the following:
- a strongly type such as PurchaseOrder as if it were an ordinary Java type
- behind the type can be an implementation that directly accesses and manipulates the underlying XML data. For example, immediately after a value is set in a strongly type, the same value can be available from any cursor that uses XPath to search the same set of data.
- FIG. 13 shows an exemplary class hierarchy diagram for an XML type API. In the Figure, the rounded boxes designate interfaces while the squared boxes designate concrete classes.
- a user starting from a file or a raw input stream can parse the XML using an XML Parser, then index the parsed file using an XML Index.
- XML types can add the schema to the Java runtime model. For example, every schema can compile into a Java type at compile time. This can include both complex types and simple types. Precompiled types such as XmlString and XmlDate can be used for the fundamental and simple types built-in to XML Schema. XMLObject itself can correspond to the xsd:anyType. In addition, for each schema, a pointer resource can be generated into the target class hierarchy that provides a map from all schemas with a given name into corresponding Java type names.
- XMLIndex can automatically resolve all XML to types using such a scheme. If no "xml world" is specified, a default world can be used. Other alternate views can also be specified that allow different versions of schemas to be used.
- One embodiment may be implemented using a conventional general purpose or a specialized digital computer or microprocessor(s) programmed according to the teachings of the present disclosure, as will be apparent to those skilled in the computer art.
- Appropriate software coding can readily be prepared by skilled programmers based on the teachings of the present disclosure, as will be apparent to those skilled in the software art.
- the invention may also be implemented by the preparation of integrated circuits or by interconnecting an appropriate network of conventional component circuits, as will be readily apparent to those skilled in the art.
- One embodiment includes a computer program product which is a storage medium (media) having instructions stored thereon/in which can be used to program a computer to perform any of the features presented herein.
- the storage medium can include, but is not limited to, any type of disk including floppy disks, optical discs, DVD, CD-ROMs, micro drive, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or optical cards, nanosystems (including molecular memory ICs), or any type of media or device suitable for storing instructions and/or data.
- the present invention includes software for controlling both the hardware of the general purpose/specialized computer or microprocessor, and for enabling the computer or microprocessor to interact with a human user or other mechanism utilizing the results of the present invention.
- software may include, but is not limited to, device drivers, operating systems, execution environments/containers, and applications.
Abstract
Description
Claims
Priority Applications (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
AU2004208330A AU2004208330B2 (en) | 2003-01-24 | 2004-01-23 | XML types in Java |
EP04704890A EP1588235A4 (en) | 2003-01-24 | 2004-01-23 | Xml types in java |
JP2006502954A JP2006516781A (en) | 2003-01-24 | 2004-01-23 | XML type in JAVA |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US44267303P | 2003-01-24 | 2003-01-24 | |
US60/442,673 | 2003-01-24 | ||
US10/762,814 | 2004-01-22 | ||
US10/762,814 US7650591B2 (en) | 2003-01-24 | 2004-01-22 | Marshaling and un-marshaling data types in XML and Java |
Publications (2)
Publication Number | Publication Date |
---|---|
WO2004068292A2 true WO2004068292A2 (en) | 2004-08-12 |
WO2004068292A3 WO2004068292A3 (en) | 2005-12-22 |
Family
ID=32829798
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US2004/001827 WO2004068292A2 (en) | 2003-01-24 | 2004-01-23 | Xml types in java |
Country Status (5)
Country | Link |
---|---|
US (1) | US7650591B2 (en) |
EP (1) | EP1588235A4 (en) |
JP (1) | JP2006516781A (en) |
AU (1) | AU2004208330B2 (en) |
WO (1) | WO2004068292A2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US11645129B2 (en) | 2021-03-19 | 2023-05-09 | Oracle International Corporation | Dynamically-imposed field and method type restrictions for managed execution environments |
Families Citing this family (72)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7721193B2 (en) | 2001-10-18 | 2010-05-18 | Bea Systems, Inc. | System and method for implementing a schema object model in application integration |
US7516447B2 (en) | 2002-02-22 | 2009-04-07 | Bea Systems, Inc. | Methods and apparatus for building, customizing and using software abstractions of external entities |
US8135772B2 (en) | 2002-05-01 | 2012-03-13 | Oracle International Corporation | Single servlets for B2B message routing |
US7424717B2 (en) * | 2002-05-01 | 2008-09-09 | Bea Systems, Inc. | Systems and methods for business process plug-in development |
US7257645B2 (en) | 2002-05-01 | 2007-08-14 | Bea Systems, Inc. | System and method for storing large messages |
US7350184B2 (en) | 2002-05-02 | 2008-03-25 | Bea Systems, Inc. | System and method for enterprise application interactions |
US7676538B2 (en) | 2002-05-02 | 2010-03-09 | Bea Systems, Inc. | Systems and methods for application view transactions |
US7165249B2 (en) * | 2002-05-02 | 2007-01-16 | Bea Systems, Inc. | Systems and methods for modular component deployment |
US20040167915A1 (en) * | 2003-02-25 | 2004-08-26 | Bea Systems, Inc. | Systems and methods for declaratively transforming data objects between disparate representations |
US7293038B2 (en) | 2003-02-25 | 2007-11-06 | Bea Systems, Inc. | Systems and methods for client-side filtering of subscribed messages |
US7752599B2 (en) * | 2003-02-25 | 2010-07-06 | Bea Systems Inc. | Systems and methods extending an existing programming language with constructs |
US7774697B2 (en) * | 2003-02-25 | 2010-08-10 | Bea Systems, Inc. | System and method for structuring distributed applications |
US8032860B2 (en) | 2003-02-26 | 2011-10-04 | Oracle International Corporation | Methods for type-independent source code editing |
US7707564B2 (en) | 2003-02-26 | 2010-04-27 | Bea Systems, Inc. | Systems and methods for creating network-based software services using source code annotations |
US7650276B2 (en) | 2003-02-26 | 2010-01-19 | Bea Systems, Inc. | System and method for dynamic data binding in distributed applications |
US7299454B2 (en) * | 2003-02-26 | 2007-11-20 | Bea Systems, Inc. | Method for multi-language debugging |
US7650592B2 (en) | 2003-03-01 | 2010-01-19 | Bea Systems, Inc. | Systems and methods for multi-view debugging environment |
US7389498B2 (en) * | 2003-03-25 | 2008-06-17 | Microsoft Corporation | Core object-oriented type system for semi-structured data |
US20040193575A1 (en) * | 2003-03-25 | 2004-09-30 | Chia-Hsun Chen | Path expressions and SQL select statement in object oriented language |
US20040194057A1 (en) * | 2003-03-25 | 2004-09-30 | Wolfram Schulte | System and method for constructing and validating object oriented XML expressions |
US7366722B2 (en) * | 2003-05-15 | 2008-04-29 | Jp Morgan Chase Bank | System and method for specifying application services and distributing them across multiple processors using XML |
US20050005158A1 (en) * | 2003-07-02 | 2005-01-06 | Eyal Alaluf | Method for compiling an active server page (ASP).Net Web service into a java compliant Web service |
US7590643B2 (en) * | 2003-08-21 | 2009-09-15 | Microsoft Corporation | Systems and methods for extensions and inheritance for units of information manageable by a hardware/software interface system |
WO2005111851A2 (en) * | 2004-04-30 | 2005-11-24 | Microsoft Corporation | Rules framework for definition and execution of end-user rules logic |
EP1625513B1 (en) * | 2004-04-30 | 2018-04-18 | Microsoft Technology Licensing, LLC | Rules framework for definition and execution of end-user rules logic |
US7912863B1 (en) * | 2004-07-30 | 2011-03-22 | Microsoft Corporation | Compositional lifting of operations over structural types |
US7774376B1 (en) | 2004-07-30 | 2010-08-10 | Microsoft Corporation | Type-system extensions for object-oriented language based on coercive subtyping with restrictions |
US7827197B2 (en) * | 2004-12-02 | 2010-11-02 | International Business Machines Corporation | Method for providing a pluggable custom data binding system |
US20060195411A1 (en) * | 2005-02-28 | 2006-08-31 | Microsoft Corporation | End user data activation |
US7949941B2 (en) * | 2005-04-22 | 2011-05-24 | Oracle International Corporation | Optimizing XSLT based on input XML document structure description and translating XSLT into equivalent XQuery expressions |
US20060242187A1 (en) * | 2005-04-26 | 2006-10-26 | Michael Scharf | Type safe data proxy |
US7721270B2 (en) * | 2005-07-26 | 2010-05-18 | Informatica Corporation | Information converter and a method for transforming information |
US20070061779A1 (en) * | 2005-09-13 | 2007-03-15 | Bernd Dowedeit | Method and System and Computer Program Product For Maintaining High Availability Of A Distributed Application Environment During An Update |
US8250522B2 (en) * | 2005-09-28 | 2012-08-21 | Sap Ag | Method and system for generating a web services meta model on the java stack |
US20070073771A1 (en) | 2005-09-28 | 2007-03-29 | Baikov Chavdar S | Method and system for directly mapping web services interfaces and java interfaces |
US9454616B2 (en) | 2005-09-28 | 2016-09-27 | Sap Se | Method and system for unifying configuration descriptors |
US7913223B2 (en) * | 2005-12-16 | 2011-03-22 | Dialogic Corporation | Method and system for development and use of a user-interface for operations, administration, maintenance and provisioning of a telecommunications system |
US20070153342A1 (en) * | 2006-01-05 | 2007-07-05 | Sand Anne R | Display and editing of documents described by schemas |
US8429526B2 (en) * | 2006-04-10 | 2013-04-23 | Oracle International Corporation | Efficient evaluation for diff of XML documents |
US8082493B2 (en) * | 2006-04-10 | 2011-12-20 | Oracle International Corporation | Streaming XML patch |
US20070255843A1 (en) * | 2006-04-28 | 2007-11-01 | Zubev Alexander I | Configuration of clients for multiple computer services |
US20070255719A1 (en) * | 2006-04-28 | 2007-11-01 | Sap Ag | Method and system for generating and employing a generic object access model |
US20070255720A1 (en) * | 2006-04-28 | 2007-11-01 | Sap Ag | Method and system for generating and employing a web services client extensions model |
US7818331B2 (en) * | 2006-04-28 | 2010-10-19 | Sap Ag | Retrieval of computer service type metadata |
US7587425B2 (en) | 2006-04-28 | 2009-09-08 | Sap Ag | Method and system for generating and employing a dynamic web services invocation model |
US8099709B2 (en) * | 2006-04-28 | 2012-01-17 | Sap Ag | Method and system for generating and employing a dynamic web services interface model |
US7991799B2 (en) * | 2006-06-05 | 2011-08-02 | International Business Machines Corporation | Schema specific parser generation |
US7882429B2 (en) * | 2006-06-05 | 2011-02-01 | International Business Machines Corporation | High-level virtual machine for fast XML parsing and validation |
US7802240B2 (en) * | 2006-06-26 | 2010-09-21 | Oracle America, Inc. | Mechanism for compiling programs |
US7405677B2 (en) * | 2006-08-08 | 2008-07-29 | International Business Machines Corporation | Apparatus, system, and method for incremental encoding conversion of XML data using Java |
US7631003B2 (en) * | 2007-02-20 | 2009-12-08 | Microsoft Corporation | Automated transformation for style normalization of schemas |
US7962889B2 (en) * | 2007-07-31 | 2011-06-14 | Novell, Inc. | Techniques for instantiating and configuring projects |
US8626720B2 (en) * | 2008-02-11 | 2014-01-07 | International Business Machines Corporation | System and method of reconstructing complex custom objects |
US8276111B2 (en) | 2008-12-19 | 2012-09-25 | Microsoft Corporation | Providing access to a dataset in a type-safe manner |
US8307020B2 (en) | 2009-07-24 | 2012-11-06 | Ensequence, Inc. | Method for distributing a certified application employing a pre-certified master application template |
US20110023022A1 (en) * | 2009-07-24 | 2011-01-27 | Ensequence, Inc. | Method for application authoring employing an application template stored in a database |
US8682945B2 (en) * | 2009-07-24 | 2014-03-25 | Ensequence, Inc. | Method and system for authoring multiple application versions based on audience qualifiers |
US8667460B2 (en) * | 2009-07-24 | 2014-03-04 | Ensequence, Inc. | Method for application authoring employing a child application template derived from a master application template |
US8671124B2 (en) * | 2009-07-24 | 2014-03-11 | Ensequence, Inc. | Method for application authoring employing a pre-certified master application template |
US20110022603A1 (en) * | 2009-07-24 | 2011-01-27 | Ensequence, Inc. | Method and system for authoring and distributing multiple application versions based on audience qualifiers |
US8341154B2 (en) * | 2009-10-28 | 2012-12-25 | Microsoft Corporation | Extending types hosted in database to other platforms |
US20110161325A1 (en) * | 2009-12-31 | 2011-06-30 | Ego7 Llc | System, method and computer-readable storage medium for generation and remote content management of compiled files |
US8955043B2 (en) * | 2010-01-27 | 2015-02-10 | Microsoft Corporation | Type-preserving compiler for security verification |
US20110246870A1 (en) * | 2010-04-02 | 2011-10-06 | Microsoft Corporation | Validating markup language schemas and semantic constraints |
US20120159306A1 (en) * | 2010-12-15 | 2012-06-21 | Wal-Mart Stores, Inc. | System And Method For Processing XML Documents |
US9047095B2 (en) * | 2011-07-12 | 2015-06-02 | Sap Se | Embedding of a non-imperative programming language for data transformation operations within an imperative programming language |
US9430253B2 (en) * | 2011-09-25 | 2016-08-30 | Sap Se | Reusable and late addition enabled XML data binding |
US9176712B2 (en) | 2013-03-14 | 2015-11-03 | Oracle International Corporation | Node Grouped Data Marshalling |
US10296618B1 (en) | 2013-05-20 | 2019-05-21 | EMC IP Holding Company LLC | Storage system query mechanism and techniques |
US8954441B1 (en) | 2014-01-02 | 2015-02-10 | Linkedin Corporation | Graph-based system and method of information storage and retrieval |
US9984175B2 (en) | 2015-09-30 | 2018-05-29 | International Business Machines Corporation | Mapping non-generic markup language elements to generic object-oriented programming language objects |
KR101847863B1 (en) | 2016-09-12 | 2018-04-11 | 한국철도기술연구원 | Apparatus and method of converting for railway safety data integrated transport |
Family Cites Families (65)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5187790A (en) | 1989-06-29 | 1993-02-16 | Digital Equipment Corporation | Server impersonation of client processes in an object based computer operating system |
US6012083A (en) | 1996-09-24 | 2000-01-04 | Ricoh Company Ltd. | Method and apparatus for document processing using agents to process transactions created based on document content |
US5961593A (en) | 1997-01-22 | 1999-10-05 | Lucent Technologies, Inc. | System and method for providing anonymous personalized browsing by a proxy system in a network |
US6230309B1 (en) | 1997-04-25 | 2001-05-08 | Sterling Software, Inc | Method and system for assembling and utilizing components in component object systems |
US6070184A (en) | 1997-08-28 | 2000-05-30 | International Business Machines Corporation | Server-side asynchronous form management |
US6067623A (en) | 1997-11-21 | 2000-05-23 | International Business Machines Corp. | System and method for secure web server gateway access using credential transform |
US6148336A (en) | 1998-03-13 | 2000-11-14 | Deterministic Networks, Inc. | Ordering of multiple plugin applications using extensible layered service provider with network traffic filtering |
US6850893B2 (en) | 2000-01-14 | 2005-02-01 | Saba Software, Inc. | Method and apparatus for an improved security system mechanism in a business applications management system platform |
US6338064B1 (en) | 1998-05-14 | 2002-01-08 | International Business Machines Corporation | Method for enabling a web server running a “closed” native operating system to impersonate a user of a web client to obtain a protected file |
US6721740B1 (en) | 1998-05-29 | 2004-04-13 | Sun Microsystems, Inc. | Method and apparatus of performing active update notification |
US6237135B1 (en) | 1998-06-18 | 2001-05-22 | Borland Software Corporation | Development system with visual design tools for creating and maintaining Java Beans components |
US6185734B1 (en) | 1998-07-21 | 2001-02-06 | Hewlett-Packard Company | Hierarchical registry structure for managing multiple versions of software components |
US6212546B1 (en) | 1998-10-01 | 2001-04-03 | Unisys Corporation | Providing a modular gateway architecture which isolates attributes of the client and server systems into independent components |
US6480865B1 (en) * | 1998-10-05 | 2002-11-12 | International Business Machines Corporation | Facility for adding dynamism to an extensible markup language |
US6367068B1 (en) | 1998-11-13 | 2002-04-02 | Microsoft Corporation | Dynamic parsing |
US6385724B1 (en) | 1998-11-30 | 2002-05-07 | Microsoft Corporation | Automatic object caller chain with declarative impersonation and transitive trust |
US6795967B1 (en) | 1999-01-26 | 2004-09-21 | Microsoft Corporation | Changing user identities without closing applications |
JP3762867B2 (en) | 1999-01-29 | 2006-04-05 | 富士通株式会社 | Compiler device, compiling method, and storage medium storing program therefor |
US6243737B1 (en) | 1999-04-09 | 2001-06-05 | Translink Software, Inc. | Method and apparatus for providing direct transaction access to information residing on a host system |
US7165041B1 (en) | 1999-05-27 | 2007-01-16 | Accenture, Llp | Web-based architecture sales tool |
US6662357B1 (en) | 1999-08-31 | 2003-12-09 | Accenture Llp | Managing information in an integrated development architecture framework |
US6802000B1 (en) | 1999-10-28 | 2004-10-05 | Xerox Corporation | System for authenticating access to online content referenced in hardcopy documents |
US20020010781A1 (en) | 1999-12-30 | 2002-01-24 | Tuatini Jeffrey Taihana | Shared service messaging models |
WO2001052090A2 (en) | 2000-01-14 | 2001-07-19 | Saba Software, Inc. | Method and apparatus for a web content platform |
US6643652B2 (en) | 2000-01-14 | 2003-11-04 | Saba Software, Inc. | Method and apparatus for managing data exchange among systems in a network |
US6970869B1 (en) * | 2000-05-09 | 2005-11-29 | Sun Microsystems, Inc. | Method and apparatus to discover services and negotiate capabilities |
US6950875B1 (en) * | 2000-05-09 | 2005-09-27 | Sun Microsystems, Inc. | Message conductors in a distributed computing environment |
US6792466B1 (en) * | 2000-05-09 | 2004-09-14 | Sun Microsystems, Inc. | Trusted construction of message endpoints in a distributed computing environment |
US6850979B1 (en) * | 2000-05-09 | 2005-02-01 | Sun Microsystems, Inc. | Message gates in a distributed computing environment |
US7080078B1 (en) * | 2000-05-09 | 2006-07-18 | Sun Microsystems, Inc. | Mechanism and apparatus for URI-addressable repositories of service advertisements and other content in a distributed computing environment |
US6918084B1 (en) * | 2000-05-09 | 2005-07-12 | Sun Microsystems, Inc. | Spawning new repository spaces using information provided in advertisement schema messages |
JP2003534597A (en) * | 2000-05-09 | 2003-11-18 | サン・マイクロシステムズ・インコーポレイテッド | Remote function invocation using messaging in a distributed computing environment |
US6973493B1 (en) * | 2000-05-09 | 2005-12-06 | Sun Microsystems, Inc. | Mechanism and apparatus for security of newly spawned repository spaces in a distributed computing environment |
US6922685B2 (en) | 2000-05-22 | 2005-07-26 | Mci, Inc. | Method and system for managing partitioned data resources |
US7089584B1 (en) | 2000-05-24 | 2006-08-08 | Sun Microsystems, Inc. | Security architecture for integration of enterprise information system with J2EE platform |
US6832238B1 (en) | 2000-05-24 | 2004-12-14 | Sun Microsystems, Inc. | Local transaction management |
US6836883B1 (en) | 2000-06-21 | 2004-12-28 | Microsoft Corporation | Method and system for compiling multiple languages |
US6721779B1 (en) | 2000-07-07 | 2004-04-13 | Softwired Ag | Messaging proxy system |
US7685183B2 (en) | 2000-09-01 | 2010-03-23 | OP40, Inc | System and method for synchronizing assets on multi-tiered networks |
US6594823B1 (en) * | 2000-09-13 | 2003-07-15 | Microsoft Corporation | Method and system for representing a high-level programming language data structure in a mark-up language |
US6990654B2 (en) * | 2000-09-14 | 2006-01-24 | Bea Systems, Inc. | XML-based graphical user interface application development toolkit |
US20020078365A1 (en) | 2000-12-15 | 2002-06-20 | International Business Machines Corporation | Method for securely enabling an application to impersonate another user in an external authorization manager |
US20020116454A1 (en) | 2000-12-21 | 2002-08-22 | William Dyla | System and method for providing communication among legacy systems using web objects for legacy functions |
GB0108924D0 (en) | 2001-04-10 | 2001-05-30 | Ibm | Installation of a data processing solution |
US20040015840A1 (en) * | 2001-04-19 | 2004-01-22 | Avaya, Inc. | Mechanism for converting between JAVA classes and XML |
EP1260911A1 (en) * | 2001-04-27 | 2002-11-27 | Koninklijke Philips Electronics N.V. | Internal data structure for applications intended to interface to an HTML or XML type document |
US20010029604A1 (en) * | 2001-04-27 | 2001-10-11 | Jacob Dreyband | Descriptive data construct mapping method and apparatus |
US7152090B2 (en) | 2001-06-01 | 2006-12-19 | Sun Microsystems, Inc. | Metadata-aware enterprise application integration framework for application server environment |
US7761319B2 (en) | 2001-06-08 | 2010-07-20 | Click Acqusitions, Inc. | Supply chain management |
US7437710B2 (en) | 2001-07-02 | 2008-10-14 | Bea Systems, Inc. | Annotation based development platform for stateful web services |
US6754884B1 (en) * | 2001-07-02 | 2004-06-22 | Bea Systems, Inc. | Programming language extensions for processing XML objects and related applications |
US6918107B2 (en) * | 2001-07-02 | 2005-07-12 | Bea Systems, Inc. | Programming language extensions for processing data representation language objects and related applications |
US6799718B2 (en) | 2001-07-10 | 2004-10-05 | Borland Software Corp. | Development assistance for mixed-language sources |
US6910041B2 (en) | 2001-08-23 | 2005-06-21 | International Business Machines Corporation | Authorization model for administration |
CA2358681C (en) | 2001-10-12 | 2008-01-15 | Ibm Canada Limited-Ibm Canada Limitee | Resource adapter and integrated development environment |
US7155705B1 (en) * | 2001-11-26 | 2006-12-26 | Cisco Technology, Inc. | Techniques for binding an application with a data exchange format based on tags in comments |
US6859810B2 (en) * | 2001-12-10 | 2005-02-22 | Bea Systems, Inc. | Declarative specification and engine for non-isomorphic data mapping |
US7962925B2 (en) * | 2002-02-22 | 2011-06-14 | Oracle International Corporation | System and method for XML data binding |
US6922827B2 (en) * | 2002-02-22 | 2005-07-26 | Bea Systems, Inc. | Iterative software development environment with prioritized build rules |
US7043722B2 (en) * | 2002-07-31 | 2006-05-09 | Bea Systems, Inc. | Mixed language expression loading and execution methods and apparatuses |
US20040103406A1 (en) | 2002-11-21 | 2004-05-27 | International Business Machines Corporation | Method and apparatus for autonomic compiling of a program |
US7149752B2 (en) * | 2002-12-03 | 2006-12-12 | Jp Morgan Chase Bank | Method for simplifying databinding in application programs |
US7260599B2 (en) * | 2003-03-07 | 2007-08-21 | Hyperspace Communications, Inc. | Supporting the exchange of data by distributed applications |
US7260818B1 (en) | 2003-05-29 | 2007-08-21 | Sun Microsystems, Inc. | System and method for managing software version upgrades in a networked computer system |
US6859180B1 (en) * | 2003-09-15 | 2005-02-22 | The United States Of America As Represented By The Secretary Of The Navy | Gravity-actuated submarine antenna |
-
2004
- 2004-01-22 US US10/762,814 patent/US7650591B2/en active Active
- 2004-01-23 WO PCT/US2004/001827 patent/WO2004068292A2/en active Application Filing
- 2004-01-23 JP JP2006502954A patent/JP2006516781A/en active Pending
- 2004-01-23 EP EP04704890A patent/EP1588235A4/en not_active Ceased
- 2004-01-23 AU AU2004208330A patent/AU2004208330B2/en not_active Expired
Non-Patent Citations (2)
Title |
---|
None |
See also references of EP1588235A4 |
Cited By (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US11645129B2 (en) | 2021-03-19 | 2023-05-09 | Oracle International Corporation | Dynamically-imposed field and method type restrictions for managed execution environments |
US11687388B2 (en) | 2021-03-19 | 2023-06-27 | Oracle International Corporation | Implementing optional specialization when executing code |
US11693719B2 (en) | 2021-03-19 | 2023-07-04 | Oracle International Corporation | Implementing a type restriction that restricts to a non-polymorphic layout type or a maximum value |
US11726849B2 (en) | 2021-03-19 | 2023-08-15 | Oracle International Corporation | Executing a parametric method within a specialized context |
US11782774B2 (en) | 2021-03-19 | 2023-10-10 | Oracle International Corporation | Implementing optional specialization when compiling code |
US11789793B2 (en) | 2021-03-19 | 2023-10-17 | Oracle International Corporation | Instantiating a parametric class within a specialized context |
US11836552B2 (en) | 2021-03-19 | 2023-12-05 | Oracle International Corporation | Implementing a type restriction that restricts to a maximum or specific element count |
US11922238B2 (en) | 2021-03-19 | 2024-03-05 | Oracle International Corporation | Accessing a parametric field within a specialized context |
Also Published As
Publication number | Publication date |
---|---|
US7650591B2 (en) | 2010-01-19 |
AU2004208330B2 (en) | 2010-04-29 |
EP1588235A4 (en) | 2010-05-19 |
JP2006516781A (en) | 2006-07-06 |
US20040216086A1 (en) | 2004-10-28 |
AU2004208330A1 (en) | 2004-08-12 |
WO2004068292A3 (en) | 2005-12-22 |
EP1588235A2 (en) | 2005-10-26 |
AU2004208330A2 (en) | 2004-08-12 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
AU2004208330B2 (en) | XML types in Java | |
Conrad et al. | XML conceptual modeling using UML | |
US7155705B1 (en) | Techniques for binding an application with a data exchange format based on tags in comments | |
Bolton | Pure Corba | |
US20040015840A1 (en) | Mechanism for converting between JAVA classes and XML | |
AU691031B2 (en) | System and method for providing interoperability among heterogeneous object systems | |
US8112738B2 (en) | Apparatus and method of customizable model import and export to and from XML schema formats | |
US8086560B2 (en) | Schema mapping specification framework | |
US7174533B2 (en) | Method, system, and program for translating a class schema in a source language to a target language | |
US8296730B2 (en) | Using extension methods to extend COM objects | |
US8255432B2 (en) | Mechanism for supporting indexed tagged content in a general purpose data store | |
US20070088757A1 (en) | System, method and software for creating, maintaining, navigating or manipulating complex data objects and their data relationships | |
US20050071803A1 (en) | Development environment for developing applications using a metamodel | |
US7100153B1 (en) | Compiler generation of a late binding interface implementation | |
US20040103071A1 (en) | Meta-model for associating multiple physical representations of logically equivalent entities in messaging and other applications | |
Tichelaar et al. | Famix and xmi | |
TW200416569A (en) | System and method for defining and using subclasses declaratively within markup | |
US7702691B2 (en) | Systems and methods for EJB finders using SQL | |
US7484204B2 (en) | System and method for extensible type repositories | |
Bakay et al. | The UDM framework | |
US20090106309A1 (en) | Performing an Operation on an XML Database | |
US7934193B2 (en) | Processing a module specification to produce a module definition | |
Van Cappellen et al. | XQJ: XQuery Java API is completed | |
Paternostro et al. | Advanced features of the eclipse modeling framework | |
Freidig | XMI for FAMIX |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BW BY BZ CA CH CN CO CR CU CZ DE DK DM DZ EC EE EG ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NA NI NO NZ OM PG PH PL PT RO RU SC SD SE SG SK SL SY TJ TM TN TR TT TZ UA UG US UZ VC VN YU ZA ZM ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): BW GH GM KE LS MW MZ SD SL SZ TZ UG ZM ZW AM AZ BY KG KZ MD RU TJ TM AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HU IE IT LU MC NL PT RO SE SI SK TR BF BJ CF CG CI CM GA GN GQ GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
WWE | Wipo information: entry into national phase |
Ref document number: 20048027649 Country of ref document: CN Ref document number: 2006502954 Country of ref document: JP |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2004704890 Country of ref document: EP |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2008/CHENP/2005 Country of ref document: IN |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2004208330 Country of ref document: AU |
|
ENP | Entry into the national phase |
Ref document number: 2004208330 Country of ref document: AU Date of ref document: 20040123 Kind code of ref document: A |
|
WWP | Wipo information: published in national office |
Ref document number: 2004208330 Country of ref document: AU |
|
WWP | Wipo information: published in national office |
Ref document number: 2004704890 Country of ref document: EP |