WO2003077142A1 - Method, apparatus, and system for data modeling and processing - Google Patents

Abstract

A method and system to process a domain. A domain is modeled with one or more domain models (12.2). Support models are generated from domain models. An ontological system utilizes the support models to interact with and manipulate the domain models (12.4). Further, the support models are used to describe domain model states.

Description

METHOD, APPARATUS, AND SYSTEM FOR DATA MODELING AND

PROCESSING

RELATED APPLICATIONS

[0001] This application claims the benefit of U.S. Provisional Application No.

60/361,746, filed March 4, 2002.

FIELD

[0002] An embodiment of the invention relates generally to the field of information processing and to information modeling systems, and more particularly, relates to modeling a domain, interacting with the domain and manipulating the domain.

BACKGROUND

[0003] Modern ontological systems are handicapped by inconsistent approaches to storing, searching, transmitting, and publishing data and/or services. These inconsistencies prevent modelers (e.g., the people or computer system responsible for creating the ontology) from effectively influencing the system without significant effort. For example, an ontology change may need to be reflected in a model, such as an XML Schema, as well as in any transmitted instances of the ontology such as in XML Documents, i addition, changes may also need to be reflected in the database storing the instances of models (in the case of a relational database management system (RDBMS), for example, tables may need to be modified, created, or deleted). Furthermore, object classes created for use in an object-orientated system may also need to be modified and recompiled.

[0004] Tools can significantly reduce the burden on the modeler by allowing for automatic generation of alternative forms of the models after changing an XML Schema or document type definition (DTD). However these tools in themselves are not sufficient for a robust ontology-based system that requires that such models (or instances of the models) be published, maintained, discovered, searched, transmitted or can trigger events.

SUMMARY OF THE INVENTION

[0005] A method to process a domain. The method includes modeling the domain with at least one domain model; generating support models for an ontological system to interact with and manipulate the at least one domain model; and using the support models to describe domain model states.

Brief Description of the Drawings [0006] The features of the present invention will be more fully understood by reference to the accompanying drawings, in which:

[0007] Figs, la and lb illustrate a system in accordance with one embodiment of the present invention;

[0008] Fig. 2 is a flow chart of one embodiment of a method according to the teachings of the present invention; [0009] Fig. 3 is a flow chart of an exemplary process for generating data models/components in accordance with one embodiment of the present invention;

[0010] Fig. 4 is a flow chart of an exemplary process for generating selector schemas according to one embodiment of the present invention;

[0011] Fig. 5 is a flow chart of an exemplary process for generating classes from schemas;

[0012] Fig. 6 is a flow chart of an exemplary process for generating database tables from object classes in accordance with one embodiment of the present invention;

[0013] Fig. 7 is a flow chart of an exemplary process for data transmission according to one embodiment of the present invention;

[0014] Fig. 8 is a flow chart of an exemplary search process in accordance with one embodiment of the present invention;

[0015] Fig. 9 is a flow chart of an exemplary process for event subscription process in accordance with one embodiment of the present invention;

[0016] Fig. 10 is a flow chart of an exemplary process for event notification in accordance with one embodiment of the present invention;

[0017] Fig. 11 is a flow chart of an exemplary workflow process in accordance with one embodiment of the present invention;

[0018] Fig. 12 is a flow chart of an exemplary process for data retrieval in accordance with one embodiment of the present invention;

[0019] Fig. 13 is a block diagram illustrating a system to process a domain.

[0020] Fig. 14 shows a diagrammatic representation of an exemplary machine. Detailed Description of the Invention [0021] According to one aspect of the present invention, an ontological modeling system is provided that allows for seamless integration of the ontology with various processes including but not limited to transmission, discovery, notification, searching, filtering and storing processes. The invention builds upon an ontology to allow expression of relationships between the ontology and allow for the description of various models that exist within the ontology. In one embodiment, a system is provided that allows for several processes including but not limited to ontology-based workflow, searching, and event subscription. Furthermore, the invention allows for definitions of workflow, searches and event subscription based on the models defined as being part of the modeling system.

[0022] To accomplish this integration of processes and the ontology, the present invention, in one embodiment, may be comprised of the following: (i) a set of tools capable of generating components, object classes and database tables using XML Schemas or DTD's as templates, and (ii) a set of services that utilize the components, object classes and tables generated by the tools.

[0023] In one embodiment of the invention, a human modeler creates one or more XML Schema by interacting with a computer using input and output devices. The set of tools then generates the various components such as Selector Schema, Java objects and database tables, etc. The system then utilizes these components for use with various services that may include storage of model instances, transmission of model instances, discovery of services, notification of events, and searching through stored instances. [0024] As discussed in detail herein, the present invention provides a method, apparatus, system, and machine-readable medium for establishing a consistent infrastructure for data modeling and processing including publishing, searching, describing, filtering, processing, storing and notifying based on underlying ontological models which describes an exemplary domain. Model-based component generation is an important aspect concerning the performance and usability of the overall system. Following component generation, the various components can be used by the system for various purposes and/or functions. Various aspects of component usage are discussed in detail herein including data transmission and manipulation of models, data search on a repository of models, event subscription and workflow. In addition, indirect transfer of information using URLs within models is also discussed. [0025] In one embodiment of the present invention, a system as described herein includes various components including component generation tools, components for transmission of models across systems, components for event subscription and notification, components for service publication and discovery, etc. In addition, the system may include other components such as searching components. [0026] Often a system can work alone. However, systems may also interact and such systems can be configured to communicate to each other, as shown in Fig. la, where several systems or 'nodes' are configured to interact with each other. [0027] Fig. lb illustrates a platform according to the teachings of the present invention that enables a modeler to publish models which can be incorporated into a system and used by users not only to describe model instances but also to allow for various protocols or processes for users to search for models, subscribe to events, define workflow and other system processes.

Models

[0028] In one embodiment of the present invention, the models may be defined as XML Schema and can include such features as inheritance (from other XML Schema types) as well as other features defined in the XML Schema specification. (More information regarding XML Schema specification is available for reference at www.w3c.org.) Alternatively, with minor modifications, model definitions can be created using DTDs (Document Type Definitions) or can be defined as classes (such as Java classes) or database tables, and from these alternative representations XML Schema could then be generated.

[0029] Models, in one embodiment of the present invention, can be represented as complex types, according to the XML Schema specification. The complex types can be assembled using properties that are simple types defined by the XML Schema specification and/or other complex types (that are also created in accordance with the Schema specification). Additionally, complex types can be created from other types using inheritance as specified by the XML Schema specification. [0030] In one embodiment, there are several specific models that are used by the system for various tasks, such as a workflow model, an event model and a service descriptor model. Two types of exemplary support models that are used for the system operations are discussed in more detail below, the Selector models and the Criterion models. These support models are used to describe exemplary domain models that may be passed around the system. In one embodiment, domain models may not be used explicitly by the system for basic system functionality but may be passed between systems or generated for use by particular services that reside on a given system.

Selector Schema

[0031] Selector Schemas are generated from the original Schema developed by the modeler. The Selector generator tool used in this implementation and is discussed further below in the Generation Tools section. The Selector Schemas are used by the system for a wide variety of functions, from searching a collection of models to service discovery to event subscription. Each Selector Schema allows selection criteria for a given object type to be defined.

[0032] For illustration purposes, naming conventions used in this system are the following: for a complex object defined as 'X', a Selector object created for that object is named as 'XSelector'. For example, for an object called Basketball, a Selector object call Basketballs elector would be defined. Other naming conventions of course can be used depending on the various applications and/or implementations of the present invention. In other applications or implementations, naming conventions may not be required.

[0033] For every simple property in the object being described, the Selector Schema allows selection criteria to be defined for that property using a Criterion object

(discussed further below in the Criterion Schema section). For every complex property in the object being described, the Selector Schema may contain another Selector object corresponding to the complex property type in the original object. For example, following one naming convention, if an object had a property named 'ball' of complex type 'Basketball', the Selector Schema for that object would contain a property named 'ball' of complex type 'BasketballSelector'.

Criterion Schema

[0034] For every simple property in the object being described, the Selector Schema allows selection criteria to be defined for that property. This is done using a special type created for the system, called a Criterion type. This type allows for the definition of criteria for a simple property. For example, if a model contains an integer property called 'id', the Selector Schema allows for the definition of 'id > 100' using a Criterion object. When applied in the context of a search of a collection of models, such as in a database, the Selector Schema in this case would allow the user to find all models of the type defined by the Selector that also had a 'id' property greater than the value '100'.

Model-Based Component Generation Tools

[0035] In one embodiment, there are three distinct component generation tools that are used to automatically generated components based on the model definitions created by the modeler.

[0036] Fig. 2 shows a flow diagram of a process for generating data models or objects in accordance with one embodiment of the present invention. The process can be performed by a series of tools or by a single tool comprised of these tools. Initially, the modeler generates schemas (e.g., XML Schemas) that represent objects for use by the system (block 2.1). [0037] After the models have been created as one or more XML Schemas, the Schemas are used to create new XML Schema that act as Selectors in the system (block 2.2). The creation or generation of schemas for selectors are described in more detail below. The enhanced collection of XML Schemas is then used to generate source code such as Java source code and or class files (or source code/classes for another object-orientated programming language could alternatively be created) that correspond to the objects represented in the XML Schema (block 2.3). Another tool uses the classes or source code generated in the previous tool to create database tables corresponding to the objects (block 2.4). Alternatively, the original XML Schema could be used to generate the database tables.

Generation Process

[0038] An example of a process for generating data models/components in one embodiment of the present invention is shown as Listings 1-3 and described in Fig. 3. Initially, the models to be used in the generation process are loaded and parsed by the generation tool (block 3.1) and then used by the Selector generation tool to generate Selector Schema corresponding to the original Schema (block 3.2). The original Schemas in this example are listed in Listing la-d. The generated Selector Schemas are shown as Listing 2a-2c. Following the generation of the selection Schemas, all Schemas are used by the code generation tool to create Java source code (block 3.3) that can then be compiled into Java class files. Selections of Java source code created by the code generation tool are shown as Listing 3a-3d. [0039] The table generation tool then generates database tables for the types created (block 3.4). In one embodiment, this can be done by generating table creation SQL commands and executing them on an RDBMS such as Oracle. An example of a class that does this is shown as Listing 4.

Selector Generator

[0040] Figure 4 shows a flow diagram of one embodiment of a process for generating selector schemas. Initially the generator tool loads and parses the original XML Schema into a document object model (DOM) object or another structure (block 4.1). h this example, it is assumed that there is one complex type (model) defined in the Schema. In alternative representations, there can be several complex types defined in the Schema, in which case the generator tool would iterate over each complex type defined in the Schema.

[0041] For the complex type defined in the Schema, a new DOM tree is created for the selection Schema that will correspond to the complex type (block 4.2). The generator then iterates through the properties of the complex type (block 4.3). If the next property is a simple type (block 4.4), then a Criterion object is added to the Selector object being created, with a name corresponding to the property name. The Criterion type is also added with the same upper bounds as the simple type, for example, if the property can occur once and only once, then the Criterion type for that property is allowed to be defined at most once. Note however, that all Criterion property types are optional, allowing for the system to use instances that do not necessarily define criteria for each property. Thus, the lower bound for all Criterion objects is zero. [0042] If the next property type is complex (block 4.5), then a new element of the type corresponding to the Selector type for that complex type is added to the Selector DOM tree. For example, if a complex type "Basketball" is included as a property in the parent object, then a BasketballSelector" is included in the parent Selector type. As with simple types, the same upper bound is used for the property but a lower bound of zero is used. [0043] If there are one or more other properties defined in the original complex type (block 4.6), then the same process is repeated with the next property. If not, then the assembled new type is printed out as a new Selector schema (block 4.7). The use of these Selector Schemas is discussed further below.

Class Generator

[0044] After loading an XML Schema, the code generator parses the elements in the complex type it is analyzing and creates properties in the Java code it is assembling that correspond to each child element in the complex type. For every property that is created, the code that is inserted for each property includes the property declaration (as a global property), and get/set methods for setting and getting the property. [0045] Figure 5 illustrates a flow diagram of one embodiment of a process for generating classes from schemas. Initially the generator tool loads and parses the original XML Schema into a DOM object or another structure (block 5.1). In this example, it is assumed that there is one complex type (model) defined in the Schema that will correspond to one Java class being created, h alternative representations, there could be several complex types defined in the Schema, in which case the generator tool would iterate over each complex type defined in the Schema generating several classes. [0046] The generator may create one or more string buffers and load these buffers with skeleton code for the objects to be created (block 5.2). The generator then parses through each element in the complex type (block 5.3). If the type is a simple type, it determines whether the element can occur once or more than once (block 5.4). If the element can only occur once, the simple type is converted into a Java type and a property corresponding to the name of the element is added to the code buffer for the class (block 5.5). Alternatively, if the element can occur more than once, code for a container object (such as an Array or a List) is created (block 5.6) to hold all occurrences of the property in the Java class. In this example, List objects are used as the container objects. [0047] If the next type is a complex type rather than a simple type, it is determined whether the element is allowed to occur once or more than once (block 5.7). If the element can occur only once, then a property of the Java type corresponding to the complex type of the element is added to the Java code (block 5.8). For example, under one naming convention, if the child element is called 'basketball' and is of type 'Basketball', then a property called 'basketball' of type 'Basketball' is added to the Java code, and it is assumed that the code for that object will exist on the system. In other implementations, mapping could exist to create alternative objects. Also in other implementations ,the existence of object types could be verified or otherwise guaranteed. However, in this example, the class corresponding to that object would exist (perhaps created using the class generator with another XML Schema).

[0048] Alternatively, if it is a complex type that could occur more than once, a List type is added to the Java code under the property name corresponding to the name of the element (block 5.9), similar to the case of a simple property that is allowed to occur more than once. For example, if the child element is called 'basketballs' of type 'Basketball' and could contain zero to many 'Basketball' objects, then a List type is created called 'basketballs' to hold zero to many 'Basketball' objects.

[0049] The process is repeated for all child elements in the complex type (block 5.10), and then the code that has been created is printed out (block 5.11) and optionally is compiled. This process can also be done dynamically, that is, given a new XML object type with a new schema, the Java class for that type could be automatically generated and compiled for immediate use by the system.

[0050] The class generator is also capable of handling inheritance, such that an XML complex type that extends another complex type in an XML Schema will dictate to the generation tool that the new Java class is to be created as an extension of the parent class corresponding to the parent type in the XML Schema.

Table Generator

[0051] hi one embodiment, objects are persisted or stored using an RDBMS.

Alternatively, objects could be persisted or stored in an XML database, in an object database, or in a file system.

[0052] Figure 6 illustrates a flow diagram of one embodiment of a process for generating data base tables. Initially the generator tool loads a Java class (block 6.1). In one embodiment of the present invention, the table generator inspects the properties of class files and uses those properties to create tables. Java classes can perform this inspection on other Java classes (or even themselves) using 'reflection'. Alternatively, the table generator could utilize XML Schemas instead of Java class files. The generator also obtains a connection the database and begins creating an SQL table creation statement (block 6.2) for the main table. The generator then steps through each property using reflection and determines whether the property is primitive or complex (block 6.3). If the type is primitive, a new column is added to the table creation statement (block 6.4). If the type is complex, the generation tool checks to determine (using reflection) whether the property is of type List (block 6.5). If it is of type "List", a sub-table is created for the property (block 6.6). If it is not of type "List", a new table for the contained class is created if it isn't already present in the database (block 6.7), using the same method for the new class (starting from block 6.1), or it is assumed that the generation tool will be run with that class at a later time.

[0053] After all properties have been cycled through (block 6.8), the finished table creation statement for the original class is executed (block 6.9).

Table Mapping

[0054] In some cases it may be desirable to use an existing database with the system instead of generating new tables for the objects that will be used by the system. In such a case, it is unlikely that the existing tables will correspond to the tables that would be generated by the table generation tool discussed above. However, using a table mapping tool and an adapter for query translation it is possible to use pre-existing database tables with the system.

Using a table mapping tool, it is possible to map fields of the database to the Java representation of the objects. However, these tools may not allow for searching using

Selector objects as will be described below. Instead of reinventing a similar framework with similar mapping tools, one embodiment of the present invention may utilize a 3^rd party mapping application with a special adapter class that transforms a Selector-based query into a query in the query language of the 3^rd party tool. This query is then executed and the results are translated by the 3^rd party tool into the Java representation of the objects and returned for use by the system. Retrieval and storage of any objects may also be performed utilizing the 3^rd party's API. Support for additional mapping frameworks may also be added, or a customized platform that does not require a 3^rd parties mapping tools may also be developed for the system. Data transmission

[0055] The following description describe how two systems (referred to as Node 1 and Node 2 in this example) could interoperate by using common schema and also having access to similar generation tools as previously described. Figure 7 is a flow diagram of an exemplary process for data transmission according to one embodiment of the present invention. Initially, Node 1 may retrieve one or more models from its database (block 7.1). Node 1 then uses the data retrieved to populate a Java object representing the model (block 7.2). Node 1 then translates the Java object to XML (block 7.3) and transmits the XML document to Node 2 using SOAP ("Simple Object Access Protocol")) or some other transmission protocol (block 7.4). The receiver of the XML document (Node 2, block 7.5) then translates the XML document to a Java object (block 7.6). The Java object could then be used by Node 2 to fulfill some request, or do something else such as store the Java object in its own database (block 7.7).

[0056] The various operations or functions described above require a variety of system functionality, including processes for turning an XML document into a Java object ("unmarshalling") with sample code shown as Listing 5, transforming a Java object into an XML document ("marshalling") with sample code for this process shown as Listing 6, retrieving information from the database and populating a Java object (sample code shown as Listing 7), and storing a Java object in the database (also shown in Listing 7).

Data search

[0057] In general, since the tables and persistence mechanisms are defined by the system, it also allows for the definition of a general searching method in the tables. Figure 8 shows a flow diagram of one embodiment of a searching process. A request may be generated internally or may be issued externally. The process shown in Fig. 8 can originate from an external request for a search, submitted using an XML document that contains one or more Selector elements. Initially, the system translates the XML document into Java objects (block 8.1). The system iterates through each of the top- level Selector objects (block 8.2) and uses the Selector object to query the database and retrieving the matching objects from the database (block 8.3). After iterating through each of the Selector objects (block 8.4), the retrieved objects are marshaled into XML and returned to the requestor (block 8.5). The actual process the system goes through may involve other steps, such as a security check to determine whether the requesting node has access to the data.

[0058] In one embodiment of the present invention, which utilizes an RDBMS database, the system utilizes the Selector objects to create SQL statements that search the database. Example code used for creating search SQL statements in this implementation is shown as Listing 8. If a database was used that does not correspond to the standard implementation, custom code would need to be used to create the query and retrieval for that database.

[0059] In complex query systems a search method may allow for a set of criteria to be defined, either in an AND or OR type query. In one embodiment of the present invention a single Selector object can be used (perhaps with several imbedded Selector and/or Criterion objects) to define a set of criteria that are met for a successful match. Thus, a Selector object may only allow for multi-criteria matching of the AND-type. To accomplish OR-type matching, more than one Selector object can be used. For example, if the query in a human readable for is "return all basketballs that have color=red or size=small", then two BasketballSelector objects, one with a 'color=red' Criterion object is defined and a second BasketBallSelector object can be used to obtain the basketballs with a Criterion object with 'size=smaU' defined. The union of the queries then represents all matches that fit either criterion. If the query "return all basketballs that have color=red and size=small" is desired, then one BasketBallSelector object is used with two Criterion objects, one of 'color=τed' and one of 'size=smaH'. [0060] When pre-existing tables are utilized instead of tables generated by the table generation tool a different approach to searching is required. That approach is discussed further in an above section. It should be noted here that the method of utilizing Selector objects for querying databases is superior in many respects to the standard object query systems developed for querying databases. A Selector object query can be transmitted between systems (since it can be represented as an XML document according to its XML Schema) and Selector objects can be reused across many situations required for a robust network of systems such as event subscription and service selection, which are both discussed further below.

Event subscription

[0061] Events in the context discussed here may include an object being received by a system for processing, or an object being sent out to another system, or an object being created by the system, or an object being deleted or modified by the system. There are other possible events that could be defined.

[0062] Selector objects can be used not only as a method of describing a search, but they can also be used to describe what events a system or user wishes to subscribe to. For instance, a system may wish to be notified every time a certain object is added to another system, or every time a particular object that fits certain constraints is added to or reaches another system. As an example, a system could subscribe to be notified when new objects are inserted into another system, and could use a "BasketballSelector" with a Criterion object for the "color" property, defining the object to be "purple". The system that the subscription is issued to would then notify the subscribing system whenever a "Basketball" object of "color = purple" was added to the system. [0063] Figure 9 shows a flow diagram of an exemplary process for event subscription. Two separate systems (Node 1 and Node 2) are assumed in this example, although it is possible for a system to subscribe to its own events. Node 1 sends a subscription document (in XML) to Node 2 (block 9.1). This document contains details about what events are to be subscribed to, including one or more Selector elements in the document that defines selection criteria. The receiving system then translates the event subscription document into objects and stores the objects in its database (block 9.2) using the methods/processes that are described herein.

[0064] Figure 10 illustrates a flow diagram of one embodiment of an event notification process. When an event occurs in Node 2 (block 10.1), the object that is being deleted/modified/created is used to determine which event subscriptions are valid for the event and what systems should be notified. This process involves matching the object(s) involved in the event against the database of Selector objects to determine which Selector objects match the object(s) in question (block 10.2). The subscribers that do have subscription that match the events are then notified of the event (block 10.3) using an XML document that under one embodiment of the present invention also contains the object(s) involved in the event. For example, if a new object is generated, that object is passed as part of the notification document.

Workflow

[0065] Selector objects can also be used to determine workflow. Figure 11 shows a flow diagram of an exemplary workflow process in accordance with one embodiment of the present invention. Fig. 11 depicts how a system can use Selector objects to determine workflow for a document. An example workflow document is shown as Listing 9. The workflow example shown uses several Selector objects to describe the steps of the workflow depending upon the contents of the document. Because previous steps place their results in the document (as objects corresponding to schema definitions defined for the ontology), the workflow can describe conditional workflow dependant upon the results of prior steps in the workflow. [0066] First, the system loads the workflow section of the document (block 11.1) and determines the next operation in the workflow, sending service requests to the appropriate services (local and/or remote) if necessary (block 11.2). The system then receives the results from the services and determines the next operation in the workflow (block 11.3). If there is no next operation according to the workflow (block 11.4) then the processing of the document ends. Otherwise, the next operation in processing is initiated (block 11.5).

[0067] hi one embodiment of the invention, the system utilizes a workflow document as shown as Listing 9, that contains a 'step' parameter and also a section that holds Selector objects. In one embodiment, the system iterates through each of the Workflow objects according to their step parameter. Parallel processing occurs when two Workflow objects have the same step parameters. For example, suppose there existed a document with three Workflow objects, include two objects that had "step = 1" and one Workflow object with "step = 2". In this scenario, the system would process the two objects that had the "step = 1" defined, sending requests to services described in those Workflow objects. After all services called in this process returned with results, the system would then continue and perform the service requests for the Workflow object with "step = 2". This system can also be expanded upon as needed to achieve more advanced workflow processes.

[0068] In one embodiment, each Workflow object contains a "requirements" object that holds zero-to-many Selector objects. In one embodiment, the document contains objects that meet all of the requirements specified using the Selector objects. The matching algorithm used for determining matched events (described above, in which matched Events are determined by the Selector objects of the Events matching the objects in the document) can be reused to determine whether the document contains objects that match the Selector objects. In one embodiment, the system accomplishes 'or' scenarios by having multiple Workflow objects with the same step parameter that have different Selector objects for one or the other case described by the 'or' operation. This system can also be expanded to achieve more advanced workflow processes. [0069] In one embodiment, the absence of Selector objects in the requirements section of the Workflow instructs the system to execute the services in that step regardless of the contents of the object.

Remote data retrieval

[0070] hi addition to a system that can pass actual data in models between nodes, the system is capable of passing models that might not contain all data concerning a model, but instead contain a reference to the model or, in the case of certain models that have standard annotations, a default reference to additional model information can be established.

[0071] Figure 12 shows a flow diagram of one embodiment of an exemplary process for remote data retrieval. Initially, an object might be passed to another system without certain attributes (even non-optional ones) described. A model object could be sent as an XML document (block 12.1) potentially with as little as one attribute, a unique identifier, sent in the object. Either included in the model object is a service location (block 12.2) that can be used to retrieve other attributes of the object, or in the case of agreed upon object models, the location might be a default location that the receiving system has knowledge of.

[0072] The receiving system can use this partially filled object normally, with method calls such as 'getX()' for property 'X' (block 12.3). The system then determines if that property is available in the object (block 12.4). If that property is not in the object, it can be retrieved automatically by the system using the location specified in the object or the default location (block 12.5). This request is made in one embodiment of the present invention using a SOAP request that specifies the object's uniquely identifying property. If the data is already included in the object or once that information is retrieved and used to populate the object, then the data is then returned as a response to the ^egetX()' method call (block 12.6).

[0073] The data is returned from a remote query is a partially populated model in XML and is turned into a Java object and then integrated into the existing Java object, hi one embodiment of the present invention, existing data in the existing object is not overwritten by data retrieved from this process. This process of foreign retrieval might retrieve not only the data requested but also additional data with additional properties, such that only one request is necessary to retrieve all supplemental information.

Alternative but equivalent processes

[0074] Although an embodiment of the present invention has been shown and described in some detail, along with certain variants of the invention, many other varied embodiments that incorporate the teachings of the present invention maybe constructed by those skilled in the art of the invention. Accordingly, the present invention is not intended to be limited to the specific form described herein, but it is intended that alternatives, modifications, and equivalents of the invention or steps of the invention should also be included, as is reasonable within the spirit and scope of the invention. [0075] Trivial alterations of the described invention include allowing the modeling process to be completed by algorithms or other processes acting to generate models. Another alteration would allow for 'dynamic' systems that generate components handling new XML document types at run-time (as opposed to design-time). Another alteration would allow the modeler to initially model their objects using classes or database tables (as opposed to XML Schema or DTD's) and having the generation tools construct other needed components from those different starting components, such that the generated system was similar to the system generated using XML Schema as the initial design templates.

[0076] In various embodiments the components, nodes, tools, systems and generators described herein may take the foπn of a machine.

Computer System

[0077] Figure 14 shows a diagrammatic representation of the machine in the exemplary form of a computer system 14.1 within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed. In alternative embodiments, the machine operates as a standalone device or may be connected (e.g., networked) to other machines. In a networked deployment, the machine may operate in the capacity of a server or a client machine in server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term "machine" shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.

[0078] The exemplary computer system 14.1 includes a processor 14.2 (e.g., a central processing unit (CPU) a graphics processing unit (GPU) or both), a main memory 14.4 and a static memory 14.6, which communicate with each other via a bus 14.8. The computer system 14.1 may further include a video display unit 14.10 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)). The computer system 14.1 also includes an alpha-numeric input device 14.12 (e.g., a keyboard), a cursor control device 14.14 (e.g., a mouse), a disk drive unit 14.16, a signal generation device 14.18 (e.g., a speaker) and a network interface device 14.20.

[0079] The disk drive unit 14.16 includes a machine-readable medium 14.22 on which is stored one or more sets of instructions (e.g., software 14.24) embodying any one or more of the methodologies or functions described herein. The software 14.24 may also reside, completely or at least partially, within the main memory 14.4 and/or within the processor 14.2 during execution thereof by the computer system 14.1, the main memory 14.4 and the processor 14.2 also constituting machine-readable media. [0080] The software 14.24 may further be transmitted or received over a network via the network interface device 14.20.

[0081] While the machine-readable medium 14.22 is shown in an exemplary embodiment to be a single medium, the term "machine-readable medium" should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions. The term "machine-readable medium" shall also be taken to include any medium that is capable of storing, encoding or carrying a set of instructions for execution by the machine and that cause the machine to perform any one or more of the methodologies of the present invention. The term "machine-readable medium" shall accordingly be taken to included, but not be limited to, solid-state memories, optical and magnetic media, and carrier wave signals.

[0082] Thus, a method and a system to process a domain has been described. Although the present invention has been described with reference to specific exemplary embodiments, it will be evident that various modifications and changes may be made to these embodiments without departing from the broader spirit and scope of the invention. Accordingly, the specification and drawings are to be regarded in an illustrative rather than a restrictive sense. Listings

Listing la - Patient.xsd

<?xml version="1.0" encoding="UTF-8"?>

<!-- edited with XML Spy v3.5 NT (http://wΛvw.xmlsρy.com) by Dan Adamson (Medstory) --> <xsd:schema targetNamespace="http://www.medstory.com/schemas" xmlns:xsd="http ://www. w3.org/2000/10/XMLSchema" xmlns="http://www .medstory.com/schemas" elementFormDefault="qua]jfied" attributeForrnDefault="unqualified"> <xsd:include schemaLocation="CMLObject.xsd"/> <xsd:include schemaLocation="Condition.xsd"/> <xsd:complexType name="Patient"> <xsd:complexContent>

<xsd:extension base="CMLObject"> <xsd:all>

<xsd:element name="age" type="xsd:nonNegativelnteger"/> <xsd:element name="ethnicity"> <xsd:simpleType>

<xsd:restriction base="xsd:string"> <xsd:enumeration value- ' Asian'7> <xsd:enumeration value="White"/> <xsd:enumeration value="Black"/> <xsd: enumeration value="Hispanic"/> <xsd:enumeration value="Narive American"/> </xsd:restriction> </xsd:simpleTyρe> < xsd:element>

<xsd:element name=" gender "> <xsd:simpleType>

<xsd:restriction base="xsd:string"> <xsd:enumeration value="Male"/> <xsd:enumeration value="Female" > </xsd:restriction> </xsd:simpleType </xsd:elemenl>

<xsd:element name- ' condition" type- 'Condition" minOccurs="0" maxOccurs="unbounded"/> </xsd:all> </xsd:extension> </xsd: complexContent> </xsd:complexType>

<xsd:element name="patient" type="Patient" > </xsd:schema>

Listing lb - CMLObject.xsd

<?xml version="1.0" encoding="UTF-8"?>

<!-- edited with XML Spy v3.5 NT (http://www.xmlspy.com) by Dan Adamson (Medstory) --> <xsd:schema targetNamespace="http://www.medstory.com/schemas" xm]ns="http://www.medstory.com/schemas" xmlns:xsd="h tp://www. w3.org/2000/10 XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xsd:include schemaLocation="MedstoryObject.xsd"/> <xsd:complexType name="CMLObject" abstract="true" final="restriction"> <xsd:complexContent>

<xsd:extension base="MedstoryObject"> <xsd:all>

<xsd:element name="timestamp" type="xsd:long"/> <xsd:element name="owner" type="xsd:string"/> <xsd:element name="security"> <xsd: simpleType> <xsd:enumeration value="Private"/> <xsd:enumeration value="Protected"/> </xsd:restriction> </xsd:simpleType> </xsd:element> xsd:all> </xsd:extension> </xsd:complexContent> </xsd:complexType>

<xsd:element name="cmlObject" type="CMLObject"/> </xsd:schema>

Listing lc - Meds.oryObject.xsd

<?xml version="1.0" encoding="UTF-8"?>

<!— edited with XML Spy v3.5 NT (http://www.xmlspy.com) by Dan Adamson (Medstory) — > <xsd:schema targetNamespace="http://www.medstory.com schemas" xmlns:xsd="http://www. w3.org/2000/10/XMLSchema" xm]ns="http://www.medstory.com/schemas" elementForrnDefau]t="qualified" attributeFormDefault="unqualified"> <xsd:complexType name="MedstoryObject"> <xsd:all>

<xsd:element name="moid" type="xsd:string"/> <xsd:element name="parentMoid" type="xsd:striπg"/> </xsd:all> </xsd:complexType> </xsd:schema>

Listing Id - Condition.xsd

<?xml version="1.0" encoding="UTF-8"?>

<!— edited with XML Spy v3.5 NT (http://www.xmlspy.com) by Dan Adamson (Medstory) --> <xsd:schema targetNamespace="http://www.medstory.com schemas" xmlns:xsd="http.7/www. w3.org/2000/10/XMLSchema" xmlns="http://www.medstory.com/schernas" elementFormDefault="qualifιed" attributeForrnDefault="unqualified"> <xsd:include schemaLocation="CMLObject.xsd"/> <xsd:complexType name="Condition" abstract="true" final="restriction"> <xsd: complexContent>

<xsd:extension base="CMLObject"> <xsd:all>

<xsd:element name- TCD9Classification" type="xsd:string"/> <xsd:element name="ConditionName" type="xsd:string"/> </xsd:all> </xsd:extension> </xsd:complexContent> </xsd:complexType>

<xsd:element name="condition" type="Condition"/> </xsd:schema>

Listing 2a - PatientSelector.xsd

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema xmlns:xsd="hrtp://www.w3.org/2000/10 XMLSchema" xmlns="http://www. medstory.com/schemas" targetNamespace="http://www.medstory.com/schemas" elementFor Default="qualified" attributeFormDefault="unqualified"> <xsd:include schemaLocation="CMLObjectSelector.xsd" /> <xsd:include schemaLocation="ConditionSelector.xsd" /> <xsd:complexType name="PatientSelector"> <xsd:complexContent>

<xsd: extension base="CMLObjectSelector"> <xsd:all>

<xsd:element name="age" type="Criterion" /> <xsd:element name="ethnicity" type="Criterion"> </xsd:element>

<xsd:element name="gender" type="Criterion"> </xsd:element>

<xsd:element name="condition" type="ConditionSelector" rninOccurs- 'O" maxOccurs="unbounded" /> </xsd:all> </xsd:extension> </xsd:complexContent> </xsd: complexType> </xsd:schema>

Listing 2b - Criterion.xsd

<?xml version="1.0" encoding="UTF-8"?>

<!-- edited with XML Spy v3.5 NT (http://www.xmlspy.com) by Dan Adamson (Medstory) — > <xsd:schema targetNamespace="http://www.medstory.com/schemas" xmlns="http://www.medstory.com/schemas" xmlns:xsd="http://www.w3.org/2000/10/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xsd:include schemaLocation="MedstoryObject.xsd"/> <xsd:complexType name="Criterion" abstract="true" final="restriction"> <xsd:complexContent>

<xsd : extension base="MedstoryObj ect"> <xsd:all>

<xsd:element name="value" type="xsd:string"/> <xsd:element name- Operator"> <xsd:simpleType>

<xsd:restric ion base="xsd:string">

<xsd:enumeration value="contains"/> <xsd: enumeration value="exists"/> <xsd:enumeration value="="/> <xsd:enumeration value="!="/> <xsd:enumeration value="&lt;"/> <xsd: enumeration value=">"/> <xsd:enumeration value="&lt;>"/> </xsd:restriction> </xsd:simpleType> </xsd:element>

<xsd:element name="upperValue" type="xsd:string" minOccurs- O'7> </xsd:all> </xsd : extension> < xsd:complexContent> </xsd:complexType>

<xsd:element name="criterion" type="Criterion"/> </xsd:schema>

Listing 2c - ConditionSelector.xsd

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema xmlns:xsd="http://www. w3.org/2000/10/XMLSchema" xmlns="http://www.medstory.com/schemas" targetNamespace="http://www.medstory.com/schemas" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xsd:include schemaLocation="CMLObjectSelector.xsd" /> <xsd:complexType name="ConditionSelector" abstract="true" final="restriction"> <xsd:complexContent>

<xsd:extension base="CMLObjectSelector"> <xsd:all>

<xsd:element name="ICD9Classification" type="Criterion" /> <xsd:element name="ConditionName" type="Criterion" /> </xsd:all> </xsd:extension> </xsd:complexContent> </xsd:complexType> </xsd:schema>

Listing 3a - Patient.java package com.medstory.cml. generated; public interface Patient extends CMLObject { public void setAge(int age); public int getAge(); public void setGender(String gender); public String getGender(); public void setEthnicity(String ethnicity); , public String getEthnicity(); public void setCondition(java.util.List condition); public java.util.List getCondition(); public void addCondition(Condition condition); }

Listing 3b - Patientlmpl.java package com.medstory.cml.generated; public class Patientlmpl extends CMLObjectlmpl implements Patient { private int age; private String ethnicity; private String gender; private java.util.List condition = new java.util.LinkedList();

, public void setAge(int age) { this.age = age; } public int getAgeQ { return age; } public void setGender(String gender) { this.gender = gender; } public String getGender() { return gender; } public void setEthnicity(String ethnicity) { this, ethnicity = ethnicity; } public String getEthnicityO { return ethnicity; } public void setCondition(java.util.List condition) { this.condition = condition; } public java.util.List getConditionO { return condition; } public void addCondition(Condition condition) { this.condition.add(condition); } } Listing 3c - CMLObjectlmpl.java package com.medstory.cml.generated; public class CMLObjectlmpl extends MedstoryObjectlmpl implements CMLObject { private long timestamp; private String owner; private String security; public void setOwner(String owner) { this.owner = owner;

} public String getOwner() { return owner; } public void setTimestamp(long timestamp) { this, timestamp = timestamp; } public long getTimestamp() { return timestamp; } public void setSecurity(String security) { this.security = security; } public String getSecurity() { return security; } }

Listing 3/d - PatientSelectorlmpl.java package com.medstory.cml. generated. selectors; import com.medstory.cml.generated.*; public class PatientSelectorlmpl extends CMLObjectSelectorlmpl implements PatientSelector { private Selector age; private Selector ethnicity; private Selector gender; ^■ private java.util.List condition = new java.util.LinkedList(); public void setAge(Selector age) { this. age = age; } public Selector getAge() { return age; } public void setGender(Selector gender) { this. gender = gender;

} public Selector getGender() { return gender;

} public void setEthnicity(Selector ethnicity) { this.ethnicity = ethnicity;

} public Selector getEthnicity() { return ethnicity; } public void setCondition(java.util.List condition) { this, condition = condition; } public java.util.List getConditionQ { return condition;

} public void addCondition(ConditionSelector condition) { this.condition.add(condition); } } Listing 4 - Table Creation Class package com.medstory.cml.store.permanent.rdbstore; import java.io.*; import Java. util.*; import java.lang.reflect.*; import java.sql.*;

/**

* Title:

* Description:

* Copyright: Copyright (c) 2001

* Company:

* @author

* @version 1.0 */

//FILL IN LIBRAJRY_RELATIONSHIPS!

//CREATE TABLE "MEDSTORY"."TEST_TABLE"("TEST_VARCHAR_l" VARCHAR2(255), "TEST_NUMBER_1" NUMBER, "TEST_DATE_1" DATE, "TEST_BYTE_1" BLOB, "TESTJPRIMARYJD" NUMBER NOT NULL, PRIMARY KEY(''TEST_PRIMARY_ID'')) public class RDBMapper {

/** The package name that generated classes should be given */ static final String PACKAGE = "com.medstory.cml.generated";

/** Storage for code for tables */ private Map subtables;

/** Single properties */ protected Map properties;

/** both one-to-one and one-to-many complex objects related to the parent */ protected Map complexChildren; public RDBMapperO { reset(); }

public void reset() { subtables = new HashMapO; properties = new HashMapO; complexChildren = new HashMapO; }

/** * <p>

* This is the "entry point" for generation of DB tables from an XML

* Schema. It allows a schema to be supplied, via <code>URL</code>,

* and that schema is used for input to generate tables. * </p> * @param schemaURL <code>URL</code> at which XML Schema is located.

* @throws <code>10Exception</code> - when problems in generation occurs. */ public void generateTables(String objectName) throws IOException {

//retrieve a new instance of the object Object obj = null; String className = null; try {

// Class name is root element name, with initial caps, plus "Impl" className = new StringBuffer()

.append(PACKAGE)

.append(V)

.append(objectName)

.append("Impl")

.toStringO;

Class objectClass;

// Get the class objectClass = Class.forName(className);

// Get a new instance of this class obj = objectClass.newInstance();

MethodQ methods = objectClass.getMethods();

//find each property:

//- complex objects don't do anything - they are probably already generated

//- one-to-one simple properties add to properties

//- one-to-many simple properties add to subtables

// Find the method to call, and its parameter type for (int j=0; j<methods.length; j++) { if (methods(j].getName0.startsWith("set")) {

// Since all imitators have one param, get the first one

Class[] paramTypes = methods|j].getParameterTypes();

Class paramType = paramTypesfO]; if(paramType.getName0.indexOf("java.util.") > -1) { //it is a one-to-many property

Method subMethod = null;

//check it's type with the add method for (int k=0; k<methods.length; k++) { if(methods[k].getName().equals("add" + methods[j].getName0.substring(3))) subMethod = methodsfk];

} paramTypes = subMethod.getParameterTypes(); paramType = paramTypestO]; if ((paramType.getName0.indexOt("java.lang.") > -1) ||(paramType.getName().indexOi(".") == -1)) { subtables.put(subMethod.getName().substring(3), DataMapping.getInstance().getDBType(paramType.getName()));

} else {

//it is a complex one-to-many type complexChildren.put(methods[j].getName().substring(3), paramType.getName());

}

} else if ((paramType.getName().indexOf("java.lang.") > -1) ||(paramType.getName().indexOι(".") = -1)) { // Convert the element to the class type properties.put(methodsU].getName().substring(3), DataMapping.getInstance().getDBType(paramType.getName()));

} else { //it is a complex one-to-one type complexChildren.put(methods[j].getName().substring(3), paramType.getName()); } } }

} catch (Exception e) { throw new IOException(e.getMessage()); } }

/** * <p>

* This will write out the generated tables to the supplied db.

* <lp> *

* @param directory <code>Connection</code> to write to (should be a directory).

* ©throws <code>IOException</code> - when output errors occur. */ public void writeOutTables(Connection con, String tableName) throws lOException { try {

//delete the previous tables

Statement stmt = null;

StringBuffer sb = new StringBufferO;

PreparedStatementps = con.prepareStatement("insert into LD3RARY_RELAΗONSHIPS values

(?,?,?,?)"); try { sb.append("DROP TABLE CML_") . append( tableName) ;

System.out.ρrintln(sb.toString()); stmt = con.createStatement(); stmt.execute(sb.toStringO); stmt.close(); } catch (Exception e) {

//ignore this, the table may not exist }

//write out the main table

Iterator i = properties.keySet().iterator(); sb = new StringBuffer(); sb.append("CREATE TABLE CML_")

. apρend(tableName)

.appendO'C);

String propertyName; while (i.hasNext()) { propertyName = (String)i.next(); sb.append(propertyName)

.append(" ")

.append((String)properties.get(propertyName))

.appendf, "); } sb.appendC'PPJMARY KEY(MOID))");

System.out.priήtln(sb.toString());

//create the table stmt = con.createStatement(); stmt.execute(sb.toStringO); stmt.close();

// Now create subtables and also fill in LIBRARY_RELAΗONSHIPS i = subtables.keySetO-iterator ; while (LhasNextQ) {

String subtable = (String)i.nextO;

//delete the table sb = new StringBuffer(); sb.append("DROP TABLE CML_")

.append( tableName)

.append("_")

.a pend(subtable);

System.out.printIn(sb.toString()); stmt = conxreateStatementO; stmt.execute(sb.toString()); stmt.closeO;

StringBuffer sbTableName = new StringBufferO; sbTableName.append("CML_")

.a pend(tableName)

.append("_")

.aρpend(subtable); //write out the table sb = new StτingBuffer(); sb.appendf CREATE TABLE CML_")

.append(sbTableName.toStringO)

.append("(PARENT_MOID NUMBER, VALUE ")

.append((String)subtables.get(subtable))

.appendC')");

System.out.println(sb.toString()); stmt = con.createStatement(); stmt.execute(sb.toStringO); stmt.close();

//add to LrøRARYJ ELATIONSHIPS ps.setStringO, tableName); ps.setString(2₎ subtable); ps.setString(4_> sbTableName.toStringO); ps.setString(3, (String)subtables.get(subtable)); ps.execute();

}

//also add associated complex types library relationships i = complexChildren.keySet().iterator(); while (i.hasNext()) {

String type = (String)complexCbildren.get(i.nextO); ps.setString(l, tableName); ρs.setString(2, type.substring(type.lastIndexOf('.')+l)); ps.setString(3, type); ps.setString(4, "CML_" + type.subslringttype.laslIndexO^'. +l)); ρs.execute(); } ps.close();

} catch (Exception e) { e.printStackTrace(); throw new lOException (e.getMessageO); }

* <p>

* This provides a static entry point for class generation from

* XML Schemas. * < p> *

* @param args <code>String[]</code> list of files to parse. */ public static void main(String[] args) {

RDBMapper mapper = new RDBMapper(); if (args.length = 0) { args = new String[8]; args[0] = "ActiveModel"; argsfl] = "Notification"; args[2] = "MedstoryObject"; args[3] = "Condition"; args[4] = "Router"; args[5] = "Security"; args[6] = "Patient"; args[7] = "CMLObject";

} try {

//todo: make connection Connection con= null;

DriverManager.registerDriver(ne oracle.jdbc.driver.OracleDriver ); con = DriverManager.getConnection(''jdbc:oracle:thin:@64.14.8.99:1521:main''_> "new_node", "medstory");

Statement stmt = con.createStatement(); stmt.execute("DELETE FROM LB3RARY_RELATIONSHIPS"); stmtxloseO; for (int i=0; i<args.length; i++) { mapper.generateTables(args[i]); mapper. riteOutTables(con, args[i]); mapper.resetO; }

} catch (SQLException e) { System.out.println("Could not locate database: "); e.printStackTraceO; } catch (lOException e) { //System.out.println("Table generation failed: "); //e.printStackTraceO; } } } Listing 5 - Unmarshalling Class package com.medstory.cml. binding; import Java. io. lOException; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import java.net.URL; import java.util. Iterator; import java.util.List; import org.jdom.Attribute; import org.jdom.Document; import org.jdom.Element; import org.jdom.JDOMException; import org.jdom.Namespace; import org.jdom.input.SAXBuilder;

/** * <p>

* <code>Unmarshaller</code> takes an XML instance document, which should

* conform to some XML Schema, and creates a Java object from the XML

* document. This object is an instance of the implementation class, which

* in turn implements the interface, created from using

* <code> {@link SchemaMapper#generateClasses} </code> upon the XML Schema. * </p>

* <p>

* It also assumes that the generated interface and implementation classes

* are in the classpath, as it will perform a <code>Class.forName</code> on

* the classes.

* </p> *

* @author Brett McLaughlin

* @author Dan Adamson */

//Modifications:

111. package name handled

112. handles unbounded types with Lists

113. removed attributes - prints out as elements only public class Unmarshaller {

/** A package name that these classes should be given */ private static final String PACKAGE = "com.medstory.cml.generated";

* <p>

* Simple constructor. * </p> */ public UnmarshallerO { // Currently, do nothing

} /** * <p>

* This method is the public entry point for unmarshalling an object from

* an XML instance document.

* </p> *

* @param instanceURL <code>URL</code> for the instance document.

* @retum <code>Object</code> - the created Java object, or

* <code>null</code> if problems occur in a way that does not

* generate an <code>Exception</code>.

* @throws <code>IOException</code> when errors in binding occur. */ public static Object unmarshall(URL instanceURL) throws lOException { // Read in the document SAXBuilder builder = new SAXBuilder(); try {

Document doc = builder .build(instanceURL);

Element rootElement = doc.getRootElement();

Unmarshaller unmarshaller = new Unmarshaller(); return unmarshaller.getJavaRepresentation(rootElement); } catch (JDOMException e) { throw new lOException (e.getMessage());

}

/** * <p>

* This method is the public entry point for unmarshalling an object from

* an XML instance document.

* </p> *

* @param doc <code>Document< code> describing the instance.

* @return <code>Object</code> - the created Java object, or

* <code>null</code> if problems occur in a way that does not

* generate an <code>Exception< code>.

* @throws <code>IOException</code> when errors in binding occur. */ public static Object unmarshall(Document doc) throws lOException { // Read in the document SAXBuilder builder = new SAXBuilderO; Element rootElement = doc.getRootElementO; Unmarshaller unmarshaller = new Un arshallerO; return unmarshaller.getJavaRepresentation(rootElement);

}

/** * <p>

* This will take an XML document fragment, starting with the provided

* <code>Element</code>, and convert it to a Java representation.

* </p> *

* @param rootElement <code>Element</code> to begin processing on.

* @return <code>Object</code> - unmarshalled Java object.

* @throws <code>IOException</code> - when XML cannot be converted to Java.

*/ private Object getJavaRepresentation(Element rootElement) throws lOException {

Object obj = null; String className = null; try { Namespace ns = rootElement.getNamespace();

// Class name is root element name, with initial caps, plus "Impl" className = new StringBuffer()

.append(PACKAGE)

.apρend(V)

.apρend(BindingUtils.initialCaps(rootElement.getName()))

.append("Impl")

.toStringO;

Class objectClass;

// Get the class objectClass = Class.forName(className);

// Get a new instance of this class obj = objectClass.newInstance();

Methodf] methods = objectClass.getMethods();

// For each attribute, get its name and call mutator List attributes = rootElement. getAttributesQ; for (Iterator i = attributes.iteratorO; i.hasNext(); ) { Attribute art = (Attribute)i.next ;

// Only want attributes for this namespace if ((!att.getNamespace0.equals(ns)) &&

( ! att.getNamespace0.equals(Namespace.NO_NAMESPACE))) { continue; }

// Determine method to call

String methodName = new StringBufferO

.append("set")

.apρend(BindingUtils.initialCaρs(att.getName ))

.toStringO;

// Find the method to call, and its parameter type for (int j=0; j<methods.length; j++) { if (methods[j].getName0.equals(methodName)) { // Since all imitators have one param, get the first one Class[] paramTypes = methods[j].getParameterTypes ; Class paramType = paramTypesfO];

Object param = DataMapping.getParameter(att.getNalueO, paramType); // Invoke the method methods[j].invoke(obj, new ObjectQ { param }); }

// Now do complex objects

List elements = rootElement.getChildren(); for (Iterator i = elements.iterator(); i.hasNext(); ) { Element element = (Element)i.next();

// Only want elements for this namespace if (( ! element.getNamespace().equals(ns)) &&

(!element.getNamespace().equals(Namesρace.NO_NAMESPACE))) { continue;

}

// Determine method to call

String methodName = new StringBuffer()

.append("set")

.append(BindingUtils.initialCaps(element.getName()))

.toStringO;

// Find the method to call, and its parameter type for (int j=0; j<methods.length; j++) { if(methods[j].getName().equals(methodName)) { // Since all mutators have one param, get the first one Classf] paramTypes = methods[j].getParameterTypesO; Class paramType = paramTypes[0];

Object param = null;

//System.out.println(paramType.getNameO); i%)aramType.getName0.indexOf "java.util.") > -1) {

//check if we already filled this parameter String getMethod = new StringBufferO

.append("get")

.append(BindingUtils.initialCaps(element.getName()))

.toStringO;

Method m = objectClass.getMethod(getMethod, null); param = m.invoke(obj, new Object[] { });

((java.util.List) paτam).add(getJavaRepresentation(element));

} else if ((paramType.getName().indexOf "java.lang.") > -1) ||(paramType.getName().indexOf(".") = -1)) {

// Convert the element to the class type param = DataMapρing.getParameter(element.getText(), paramType); } else {

// Convert the type we have to the correct type param = getJavaRepresentation(element); }

// Invoke the method methods[j].invoke(obj, new ObjectQ { para });

} } } } catch (ClassNotFoundException e) { throw new IOException("The class that the XML instance document " + "should be unmarshalled as an instance of, " + className + ", must be generated and on the classpath."); } catch (InstantiationException e) { throw new IOException("Could not create a new instance of the " + "class " + className); } catch (IllegalAccessException e) { throw new IOException("Could not access the class " + className); } catch (IllegalArgumentException e) { throw new IOException("Could not pass arguments to mutator " + "method on new instance."); } catch (InvocationTargetException e) { throw new IOException( "Error in accessing mutator on new " + "instance of class."); } catch (NoSuchMethodException e) { throw new IOExceρtion("Error in accessing accessor on new " + "instance of class."); } return obj;

Listing 6 - Marshalling Class package com.medstory.cml.binding; import Java. io. lOException; import java.io.OutputStream; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import org.jdom.Attribute; import org.jdom.Document; import org.jdom.Element; import org.jdom.Namespace; import org.jdom.output.XMLOutputter;

/** * <p>

* <code>Marshaller</code> takes a Java <code>Object</code> instance and writes

* out an XML representation of that object, with each property (variable)

* of the instance and its value.

* </p>

*

* ©author Brett McLaughlin

* ©author Dan Adamson

*/

//Modifications:

111. package name handled

112. handles complex subtypes iteratively //3. handles unbounded types with Lists //4. added namespaces output

115. removed attributes - elements only public class Marshaller {

/** Location of the schema instance namespace */ private static final String SCHEMAJ-NSTANCEJURI = "http://www.w3.org/2000/10/XMLSchema- instance"; private static final String SCHEMA_INSTANCE_PREFrX ="xsi";

/** Location of the schema instance namespace */ private static final String SCHEMA_LOCAL_URI = "http://www.medstory.com/schemas";

/** A package name that these classes should be given */ private static final String PACKAGE = "com.medstory.cml.generated"; private Namespace ns;

/**

* <p>

* Simple constructor.

* </p>

*/ public Marshaller() { ns = Namespace.getNamespace(SCHEMA_LOCAL_URI);

/** * <p>

* This method is the public entry point for marshalling an object into

* an XML instance document.

* </p>

*

* @param obj <code>Object</code> to convert to XML.

,* @ρaram out <code>OutputStream</code> to write XML to.

* ©throws <code>IOException</code> when errors in output occur. */ public static void marshall( Object obj, OutputStream out) throws lOException {

Marshaller marshaller = new Marshaller(); marshaller.writeXMLRepresentation(obj, out); }

/** * <p>

* This method is the public entry point for marshalling an object into

* an XML instance document.

* </p> *

* ©param obj <code>Object</code> to convert to XML.

* ©param out <code>Document</code> that contains the XML representation of the object.

* ©throws <code>IOException</code> when errors in output occur. */ public static Document marshall(Object obj) throws lOException {

Marshaller marshaller = new Marshaller(); return marshaller. writeXMLRepresentation(obj); }

/** * <p>

* This will take a Java object instance, and convert it into an

* XML document, and write that document to the supplied output stream.

* </p> *

* ©param obj <code>Object</code> to convert to XML.

* ©param out <code>Document</code> object to be written out.

* ©throws <code>IOException</code> when errors in output occur. */ private Document writeXMLRepresentation(Object obj) throws lOException {

// Root Element is the start of recursion

Element root = getXMLRepresentation(obj, true); return new Document(root);

}

/** * <p>

* This will take a Java object instance, and convert it into an

* XML document, and write that document to the supplied output stream. * </p> *

* ©param obj <code>Object</code> to convert to XML.

* ©param out <code>OutputStream</code> to write XML to.

* ©throws <code>IOException</code> when errors in output occur. */ private void writeXMLRepresentation( Object obj, OutputStream out) throws lOException {

Document doc = writeXMLRepresentation(obj);

// Use 2 space indentation and line feeds XMLOutputter outputter = new XMLOutputter(" ", true); outputter.output(doc, out); }

* <p>

* This is the granular portion of binding; a Java <code>Object</code> is

* converted into an XML element (in JDOM form), using recursion for any

* children. * </p>

*

* ©param obj <code>Object</code> to get the XML element representation for.

* ©return <code>Element</code> - representation of <code>Object</code> in XML.

* ©throws <code>IOException</code> when errors occur in binding. */ private Element getXMLRepresentation(Object obj, boolean addNamespace) throws lOException { Class objectClass = obj.getClass();

// Get the name of the element for this object String objectName = objectClass.getNameO; if(objectName.indexOf(PACKAGE) != -l) objectName = objectName.substring(objectName.lasundexOf('.') + 1); objectName = BindingUtils.initialLowercase(objectName);

// If this is an "Impl" class, remove that from the name int index = -1; if((mdex = objeclName.indexOf("]rnpl'')) != -l) { objectName = objectName.subsrring(0, index); }

Element element = new Element( objectName, ns); if (addNamespace) {

StringBuffer schemaLocation = new StringBuffer(128); schemaLocation.append(SCHEMA_LOCAL_URI)

.append("\n")

.append(BindingUtils.initialCaps(objectName))

.append(".xsd");

Namespace sche aNamespace = Namespace.getNamespace(SCHEMA_INSTANCE_PREFIX, SCHEMA_INSTANCE_URI); element.addNamespaceDeclaration(schemaNamespace); element. addAttribute(new Attribute("schemaLocation", schemaLocation.toStringO, schemaNamespace));

}

Method[] methods = objectClass.getMethods(); for (int i=0; i<methods.length; i++) {

// Only want accessor methods, but not the getClass() method in Object

Method method = methods[i]; if ((method.getName().startsWith("get")) && (!method.getName().equals("getClass"))) {

// Get the value for this method try {

Object o = method. invoke(obj, new Object[] { });

// For the name, remove the "get" and lower the initial letter

String propertyName = BindingUtils.initialLowercase(method.getName().substring(3)); if(o != null) {

// Determine if it's primitive by seeing if it's a java.lang type if (o.getClass().getName().startsWith("java.lang.")) {

// If it's a primitive, add as an element element.addContent(new Element(propertyName, ns).addContent(o.toStringO)); } else if (o.getClass().getName().startsWith("java.util.")) {

// this is a bunch of objects java.util.Iterator iter = ((java.util.List)o).iterator(); while (iter.hasNext()) element.addContent(getXMLRepresentation(iter.next(), false)); } else {

// ... otherwise, recurse and add new element as child element.addContent(getXMLRepresentation(o, false)); } }

} catch (IllegalAccessException e) { throw new IOException(e.getMessage()); } catch (InvocationTargetException e) { throw new IOException(e.getMessage()); } } } return element; } } Listing 7 - Database Storage/Retrieval Class package com.medstory.cml.store.permanent.rdbstore; import Java. io.*; import java.sql.*; import java.rmi.*; import javax.ejb.*; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import java.util.*; import corαmedstory. exception.*; import com.medstory.cml.store.*; import com.medstory.cml.generated.*; import com.medstory.cml.binding.*;

/**

* Title:

* Description:

* Copyright: Copyright (c) 2001

* Company:

* ©author

* ©version 1.0 */ public class RDBStore {

/** A package name that generated classes should be given */ static final String PACKAGE = "com.medstory.cml.generated"; public static boolean insertObject(MedstoryObject mo, Connection con) { boolean success = false; String id = null; Statement stmt = null; tτy {

Class objectClass = mo.getClassO;

// Get the name of the element for this object String objectName = objectClass.getName(); if(objectName.indexOf(PACKAGE) != -1) objectName = objectName.substring(objectName.lastIndexOf('.') + 1);

//objectName = BindingUtils.initialLowercase(objectName);

// If this is an "Impl" class, remove that from the name int index = -1; if ((index = objectName.indexOf("Impl")) != -1) { objectName = objectName.substring(0, index); }

//todo - fix this part //the mo_id shouldn't exist so we should assign a new one id = mo.getMoid();

//delete this object and subobjects from the db - this shouldn't occur //removeObject(id, con);

//write the objectName to the database

StringBuffer sb = new StringBuffer(); sb.append("insert into CML_")

.append( objectName)

.appendC'O;

//iterate through properties while saving the values StringBuffer sbValues = new StringBuffeτ();

Methodf] methods = objectClass.getMethods(); for (int i=0; i<methods.length; i++) {

// Only want accessor methods, but not the getClass() method in Object

Method method = methods[i]; if ((method.getName().startsWith("get")) && (!method.getName().equals("getClass"))) {

// Get the value for this method try {

Object o = method.invoke(mo, new ObjectQ { });

// For the name, remove the "get" and lower the initial letter String propertyName = method.getName().substring(3);

//non-initialized variables may exist if(o != null) { // Determine if it's primitive by seeing if it's a java.lang type if((o.getClass0.getName0.startsWith("java.lang."))

IKo.getClassO.getNameO.indexOfC.') = -1)) {

// if ifs a primitive, add to the insert statement sb.append(propertyName); sb.append(", "); sbValues.aρpend(o.toStringO); sbValues.append(", ");

} else if (o.getClass0.getName0.starts ith("java.util.")) { java.util.Iterator iter = ((]^'ava.util.List)o).iterator(); while (iter.hasNextO) {

Object newObject - iter.next(); if((newObject.getClass0.getName0.startsWith("java.lang.")) H(newObject.getClass0.getName().indexOf(".") == -1)) { // it's a primitive -add to the right subtable

StringBuffer sbStmt = new StringBuffer(); sbStmt.append("insert into CML_"); sbStmt.append(objectName); sbStmt.append("_"); sbStmt.append(propertyName); sbStmt.append(" (ρarent_moid, value) values ("); sbStmt.append(id); sbStmt.append(", ");

//todo: fix this sbStmt.append(newObject.toStringO); sbStmt.appendf)"); stmt = con.createStatement(); stmt.execute(sbStmt.toStringO);

} else { //must be a complex type -add each independently, setting its parent moid ((MedstoryObject)o).setParentMoid(id); success = insertObject((MedstoryObject)o, con);

} } } else { // ... otherwise, recurse and add to the correct object table, setting its mo_id

((MedstoryObject)o).setParentMoid(id); success = insertObject((MedstoryObject)o, con);

} } } catch (IllegalAccessException e) { throw new IOException(e.getMessageO); } catch (InvocationTargetException e) { throw new IOException(e.getMessageO); } } } sb.append(") values (") .append(sb Values) .appendO"); stmt = conxreateStatementO; success = stmt.execute(sb.toStringO);

} catch (Exception e) {

//new MedstoryException("RDBStore: insertObject exception - ", e); e.printStackTraceO; } return success; } public static boolean removeObject(String moid, String type, Connection con) { boolean success = false; PreparedStatement ps = null; ResultSet rs = null;

//todo: do this with transactional commit if(type.indexOf '.') > 0) type = type.substring(type.lastlndexOf('.')+l); try {

//delete all properties

StringBuffer sb = new StringBuffer(); sb.appendfdelete from CML_"); sb.append(type); sb.append(" where MOID = ?"); ps = con.prepareStatement(sb.toString ); ps.setString(l, moid); success = ps.execute();

//find all relationships and delete all child objects in their tables StringBuffer sbRemoveQuery;

//find all relationships and recurse through them ps = con.prepareStatement("select CHILD, CHILD TYPE, CHILD TABLE from LIBRARY_RELATIONS where PARENT = ?"); ps.setString(l, type); rs = ps.executeQueryO; while(rs.next()) {

String childName = rs.getString(l); String childType = rs.getString(2); String childTable = rs.getStτing(3); if(childType.startsWith("com.medstory.generated")) { //recursively call this procedure removeChild(moid, childTable, con);

} else { //its a simple type sbRemoveQuery = new StringBufferO; sbRemoveQuery.append("delete from ")

.append(rs.getString( 1 ))

.append(" where PARENT_MOID = ?"); ps.setString(l, moid); success = ps.executeO;

}

}

} catch (Exception e) { new MedstoryException("RDBStore: removeObject exception - ", e); } return success; } public static boolean removeChild(String parentld, String table, Connection con) { boolean success = false; PreparedStatement ps = null; ResultSet rs = null;

StringBuffer sblds = new StringBuffer(); List idList = new ArrayList();

//todo: do this with transactional commit

. try {

//find each related property

StringBuffer sb = new StringBuffer(); sb.append("select MOID from "); sb.append(table); sb.append(" where PARENTMOID = ?"); ps = con.prepareState ent(sb.toStringO); ρs.setString(l, parentld); rs = ps.executeQueryO;

String id; boolean firstld = true; while (rs.nextO) { id = rs.getString(l); if (firstld) firstld = false; else sblds.append(" or "); sblds.append(id); idList.add(id); }

//delete them all sb = new StringBufferO; sb.append("delete from "); sb.append(table); sb.append(" where PARENTMOID = ?"); ps = con.prepareStatement(sb.toString()); ρs.setString(l, parentld); success = ps.execute();

//find all relationships and delete all child objects in their tables StringBuffer sbRemoveQuery;

//find all relationships and recurse through them ps = con.prepareStatementC'select CHILD, CHILD_TYPE, CHILD TABLE from LffiRARYJ ELATIONS where PARENT = ?"); ps.setStringO, table. substring(4)); rs = ps.executeQueryO; while(rs.next()) {

String childName = rs.getString(l); String childType = rs.getString(2); String childTable = rs.getSrring(3);

Iterator iter = idList.iterator(); while (iter.hasNext()) { if(childType.startsWith("com.medstory.generated")) {

//recursively call this procedure removeChild((String)iter.next(), childTable, con);

} else { //todo: make this one query //its a simple type sbRemoveQuery = new StringBuffer(); sbRemoveQuery.append("delete from ") .append(rs.getString(l)) .append(" where PARENT_MOID = ?"); ps.setString(l, (String)iter.next()); success = ps.execute();

} } } } catch (Exception e) { new MedstoryException("RDBStore: removeObject exception - ", e);

} return success; } public static boolean modifyObject(MedstoryObject mo, Connection con) {

//todo: do this transactionally safe boolean success = false; success = removeObject(rno.getMoid0, mo.getClass0.getName(), con); success = insertObject(mo, con); return success; } public static MedstoryObject getObjectFromParent(String id, String type, Connection con) { return null; } public static MedstoryObject getObject(String id, String type, Connection con) { boolean success = false; ResultSet rs = null; MedstoryObject mo = null; Object obj = null; String className = null; PreparedStatement ps = null; StringBuffer sb = new StringBuffer(); try {

// get an instance of the class className = new StringBuffer()

.append(PACKAGE)

.append(V)

.append(BindingUtils.initialCaps(type))

.appendC'Impl")

.toStringO;

// Get the class

Class objectClass = Class.forName(className);

// get a new instance of this class to populate it obj = objectClass.newInstanceO;

// get all the simple properties sb.append("select * from CML_")

.append(type)

.append(" where MOID = ?"); ps = con.prepareStatement(sb.toString()); ps.setString(l, id); rs = ps.executeQueryO; i .rs.next()) { rsxloseO; return null; }

MethodQ methods = objectClass.getMethodsO;

// find all the get methods and populate the object for (intj=0;j<methods.length;j-H-) { if (methods[j].getName().starts im("set")) { // Since all mutators have one param, get the first one

String propertyName = methods[j].getName0.substring(3);

Classf] paramTypes = methods[j].getPararneterTypesO; Class paramType = paramTypesfO];

Object param = null;

//check if its a list type if(paramType.getName().indexOf("java.util.") > -1) {

//check if this is a subtable or a full object Method subMethod = null;

//check it's type with the add method for (int k=0; k<methods.length; k++)

//todo: use a buffer for performance here if (methods[k].getName().equals("add" + propertyName)) subMethod = methods[k]; }

paramTypes = subMethod.getParameterTypes(); paramType = paramTypes[0]; if ((paramType. getName().indexOf("java.Iang.") > -1) ||(paramType.getName().indexOf(".") == -1)) {

//get all the values from the subtable StringBuffer. sb2 = new StringBuffeτ(); sb2.append("select VALUE from CML_")

.append(type)

.append("_")

. append(ρropertyName)

.append(" where PARENT_MOID=?");

PreparedStatement ps2 = con.prepareStatement(sb2.toStringO);

//todo: this should be an int ps2.setString(l, id);

ResultSet rs2 = ps2.executeQuery(); while (rs2.next()) { param = DataMaρping.getParameter(rs2.getString(propertyName), paramType);

// invoke the method to populate the object subMethod.invoke(obj, new Object[] { param }); } rs2.close();

} else { //it is a bunch of complex types

//get all the MOIDS from the subtable StringBuffer sb2 = new StringBufferO; sb2.append("select MOID from CML_")

.append(propertyName)

.apρend(" where PARENTMOLD=?");

PreparedStatement ps2 = con.prepareStatement(sb2.toStringO);

//todo: this should be an int ps2.setString(l, id);

ResultSet rs2 = ps2.executeQuery(); while (rs2.next()) { param = (Object) getObject(rs2.getString(l), type, con); // invoke the method to populate the object subMethod.invoke(obj, new Objectf] { aram });

} rs2xlose();

}

} else if ((paramType.getName().indexOf("java.lang.") > -1) ||(paramType.getName().indexOf ".") = -1)) { // get the value from the result set param = DataMapping.getParameter(rs.getString(propertyName), paramType);

// invoke the method to populate the object methods[j].invoke(obj, new Object[] { param });

} else { // this is a single MedstoryObject StringBuffer sb2 = new StringBuffer(); sb2.append("select MOID from CML_") . append(propertyName) .append(" where PARENTMOID=?");

PreparedStatement ps2 = con.prepareStatement(sb2.toString());

//todo: this should be an int ps2.setString(l, id);

ResultSet rs2 = ps2.executeQueryO; rs2.next(); try { param = (Object) getObject(rs2.getString(l), type, con);

} catch (Exception ex) { ex.printStackTraceO;

}

// invoke the method to populate the object methods[j].invoke(obj, new ObjectfJ { param }); rs2.closeO;

} } } rsxloseO;

} catch (Exception e) {

//new MedstoryException("RDBStore: getObject exception - ", e); e.printStackTraceO; } try { mo = (MedstoryObject) obj; } catch (Exception ex) { ex.printStackTrace(); } return mo;

Listing 8 - Database Search Class package com.medstoryxml.store permanent.rdbstore; import java rmi.*; import javax.ejb.*; import javax.nammg.*; import javax.rmι.*; import java.lang.reflect.*; import java.util.*; import java sql.*; import com.medstoryxml.binding.^:| import com.medstory.exception.*; import com.medstoryx l.store.*; import com.medstory.cml.generated i. *^:, • import com.medstoryxml.generated.selectors.*;

/**

* Title:

* Descπption:

* Copyright: Copyright (c) 2001

* Company:

* ©author Dan Adamson

* ©version 1.0 */

Example query generated: select cml activeModehmoid from cml_activeModel where cml_activeModel.owner=' 1 ' and EXISTS

( select cml_activeModel.moid from crnl_activeModel, cml_ρatient where cmljpatient.parentmoid = cml_activeModel.moid and cml_patient.gender=T and EXISTS

( select cml_patient.moid from cml_ρatient, cml condition where cmI_condition.parentmoid=cmljpatient.moid and cml_condition. timestamp = '11'

)

) and EXISTS

( select cml_activeModel.moid from cml_activeModel, cml_condition where cm]_condιtion.parentmoid=cml_activeModel.moιd and cml_conditιon.timestamp = '10'

) and EXISTS

( select cml_activeModel.moid from cml_activeModel, cml_condition where cml_conditιon.parentmoid=cml_activeModel.moid and cml_condιtion.tunestamp = '12' )

*/ public class RDBSearch { private static final String PACKAGE = "com.medstoryxml.generated.selectors"; private static final String PARENT = "com.medstory.cml.generated";

.public Iterator search(MedstoτyObjectSelector[] mosArray, Connection con) {

List matches = new ArrayList();

String query; Statement stmt; ResultSet rs; for (int i = 0; i < mosArray.length; i++) { rry { query = getQuery(null, mosArray[i]); stmt = con.createStatement(); rs = stmt.executeQuery(query); while (rs.next()) {

' matches.add(rs.getString(l));

} } catch (Exception ex) { ex.printStackTrace(); } }

return matches.iteratorO; } private String getQuery(String parent, MedstoryObjectSelector mos){ boolean firstTerm = true;

StringBuffer localParent = new StringBufferO; StringBuffer fύllQuery = new StringBufferO; StringBuffer conditions = new StringBufferO;

// determine what object we are looking for Class objectClass = mos.getClassO;

// Get the name of the element for this object String objectName = objectClass.getName(); if(objectName.indexOf(PACKAGE) != -1) objectName = objectName.substring(objectName.lastIndexOf('.') + 1); objectName = objectName.substring(0, objectName.indexOf("Selector")); localParent.append("cml_") .append( objectName);

fullQuery.append("select "); if (parent != null) fullQuery.append(parent); else fullQuery.append(localParent.toStringO); fullQuery.append(".moid from "); fullQuery.append(localParent. toStringO); if (parent != null) { fullQuery.append(", "); fύllQuery.append(parent); } fullQuery.append(" where ");

// parse through the object and assemble the query MethodfJ methods = objectClass.getMethods(); for (int i=0; Kmethods.length; i++) {

// Only want accessor methods, but not the getClassQ method in Object

Method method = methods[i]; if ((method.getName().starts ith("get")) && (!method.getName().equals("getClass"))) {

// Get the value for this method try {

Object o = method.invoke(mos, new Objectf { });

// For the name, remove the "get" and lower the initial letter

String propertyName = BmdmgUtils.imtialLowercase(method.getName0.substring(3));

//non-initialized variables may exist if(o != null) {

// Determine if it's primitive by seeing if it's a java.lang type if (o.getClass().getName0.ends ith(".Selector")) {

Selector s = (Selector) o;

//String property = s.getPropertyO;

String value = s.getValue();

String operationType = s.getOperatoif);

//String upperValue = s.getUpperValue(); if(firsfTerm) firstTerm = false; else fullQuery.append(" and "); fullQuery.append(propertyName); fullQuery.append(operationType); fullQuery.append(value); } else if(o.getClass().getName().startsWith("java.util.")) { java.util. Iterator iter = ((java.util.List)o).iterator(); while (iter.hasNext()) { //add all of these Object newObject = iter.next(); if(newObject.getClass().getName().endsWith(".Selector")) {

// If it's a primitive insert into the query

//todo: test this out

Selector s = (Selector) o;

//String property = s.getProperty();

String value = s.getValue();

String operationType = s.getOperator(); if(firstTerm) firstTerm = false; else fullQuery.append(" and "); fullQuery.append(localParent.toString()); fullQuery.append(".moid IN ("); fullQuery.append("select PARENT JMOID from "); fullQuery.append(localParent.toStringO); fullQuery.append("_"); fullQuery.append(propertyName); fullQuery.append(" where VALUE"); fullQuery.append(operationType); fullQuery. append(value); fullQuery.append(") ");

} else { //must be a complex type if(firstTerm) firstTerm = false; else fullQuery.apρend(" and "); fullQuery.append("EXISTS ("); fullQuery.append(getQuery(localParent.toStringO, (MedstoryObjectSelector)newObject)); fullQuery.append(") ");

}

} } else { // ... otherwise, must be a MedstoryObectSelector if(firstTerm) firstTerm = false; else fullQuery.append(" and "); fullQuery.appendC'EXISTS ("); fullQuery.append(getQuery(localParent.toString(), (MedstoryObjectSelectόr)o)); fullQuery.append(") "); } } } catch (Exception e) { e.printStackTraceO; }

return fullQuery.toString();

}

Listing 9 - Workflow .xsd

<?x l version="1.0" encoding="UTF-8"?>

<!-- edited with XML Spy v4.1 U (http://www.xmlspy.com) by Dan (Medstory, Inc.) -> <xsd:schema targetNamespace="http://www.medstoryxom/schemas" xmlns="http.7/www.medstory.com schemas" xmlns:xsd="http://www.w3.org/2001/XMLSchema" elementFor riDefault- 'qualified" attributeFormDefault="unqualifϊed"> <xsd:include schemaLocation- 'MedstoryObject.xsd'7> <xsd:include schemaLocation="MedstoryObjectSelectorHolder.xsd"/> <xsd:complexType name="Workflow" abstracts "true" final="restriction"> <xsd:complexContent>

<xsd:extension base="MedstoryObject"> <xsd:all>

<xsd:element name="step" type="xsd:nonNegativeInteger"/> <xsd:element name="site" type="xsd:string"/> <xsd:element name="service" type="xsd:string'7>

<xsd:element name="requirements" type="MedstoryObjectSelectorHolder"/> </xsd:all> </xsd:extension> </xsd:complexContent> </xsd:co plexType>

<xsd: element name- ' workflow" type="Workflow'7> </xsd:schema>

Claims

In the Claims:

1. A method to process a domain, the method including: modeling the domain with at least one domain model; generating support models for an ontological system to interact with and manipulate the domain models; and using the support models to describe domain model states.

2. The method of claim 1 , which includes: modeling the domain by, generating domain models in the form of data schemas of a first type corresponding to data objects that represent the domain; generating support models in the form of data schemas of a second type based on data schemas of the first type, the data schemas of the second type corresponding to data selectors to access the domain; generating programming source code based on the data schemas of the first type and data schemas of the second type; and selectively, generating database tables based on data schemas of the first type and data schemas of the second type.

3. The method of claim 2, wherein generating data schemas of the second type includes: parsing each data schema of the first type; for each property of a respective complex data type, determining whether the respective property is a simple property type or a complex property type; and if the respective property is a simple property type, adding a criterion object to the corresponding data schema of the second type.

4. The method of claim 3, wherein generating data schemas of the second type includes: parsing each data schema of the first type into a document object model (DOM), the respective data schema of the first type containing a complex data type; creating a DOM tree for a data schema of the second type which corresponds to the complex data type;

5. The method of claim 4, which includes : if the respective property type is complex, adding a new element to the schema of the second type corresponding to the respective complex type.

6. The method of claim 5, wherein generating programming source code includes: parsing elements contained in a complex type of a data schema; and for each element contained in the complex type, creating a set of corresponding properties according to specifications of a first programming language.

7. The method of claim 6, which includes: generating data object classes based on the data schemas of the first type.

8. The method of claim 7, wherein the data object classes are Java classes.

9. The method of claim 6, wherein generating data object classes includes: parsing each data schema of the first type; creating a buffer for a data object class to be generated for the respective data schema of the first type; loading a template code for the data object class to be created into the buffer; for each element contained in a complex type of the respective data schema, determining whether the respective element is of simple type of complex type; if the respective element is of simple type, determining whether the respective element can occur more than once; and if the respective element can occur only once, converting the type of the respective element into a Java type and adding a property corresponding to the name of the respective element to the buffer.

10. The method of claim 1 , which includes using domain models with support models to remotely link domain models in a distributed ontological system.

11. The method of claim 1 , wherein processing the at least one domain models with an ontological system includes generating domain and support models in at least one alternate format without substantial loss of information, the alternate format being used to perform at least one of manipulation, string and transmitting the domain and the support models.

12. The method of claim 1 , wherein the domain is modeled using at least one of an XML Schema, a document type definition (DTD), an object produced for an object oriented language, and a relational table included in a relational database management system (RDMBS).

13. The method of claim 1 , wherein the support model is utilized to perform a search identifying a set of domain models which match search criteria.

14. The method of claim 1, wherein the support model is processed like a domain model by another support model.

15. The method of claim 1, wherein the ontological system notifies at least one of another ontological system and a user located at another ontological system upon occurrence of at least one of a condition and a state described by a plurality of support models.

16. The method of claim 1, wherein the ontological system triggers a step in a workflow based on at least one of a condition and a state that is described by a plurality of support models.

17. The method of claim 1, wherein an at least one model is utilized by an at least one of a distributed ontological system and a non-distributed ontological system.

18. A system to process a domain, the system including: a generation tool to model the domain by, generating domain models in the form of data schemas of a first type corresponding to data objects that represent the domain; a selector generation tool to generate support models in the form of data schemas of a second type based on data schemas of the first type, the data schemas of the second type corresponding to data selectors to access the domain; a code generation tool to generate programming source code based on the data schemas of the first type and data schemas of the second type; and selectively, a table generation tool to generate database tables based on data schemas of the first type and data schemas of the second type.

19. A system to process a domain, the system including: a first means to model the domain by, generating domain models in the form of data schemas of a first type corresponding to data objects that represent the domain; a second means to generate support models in the form of data schemas of a second type based on data schemas of the first type, the data schemas of the second type corresponding to data selectors to access the domain; a third means to generate programming source code based on the data schemas of the first type and data schemas of the second type; and selectively, a fourth means to generate database tables based on data schemas of the first type and data schemas of the second type.

20. A machine readable medium storing a set of instructions that, when executed by the machine, cause the machine to: model the domain with at least one domain model; generate support models for an ontological system to interact with and manipulate the domain models; and use the support models to describe domain model states.