CA2346924A1 - Apparatus and method for building modeling tools - Google Patents

Abstract

Invention for building a modeling tool that includes a meta model that has a semantic registry (Figure 2 #220) and a meta data manager (Figure 2 #240), an object/property interface (Figure 2 #260), and an object/property factory registry. The object/property factory registry is coupled to the meta model and the object/property interface. The semantic registry includes at least a predefined set of semantics (Figure 2 #230).

Description

APPARATUS AND METHOD FOR BUILDING MODELING TOOLS
CROSS-REFERENCE TO RELATED APPLICATIONS
The present application claims benefit of the filing date of U.S. Provisional Application No.
60/104,682 entitled MODELING TOOL SYSTEMS AND METHODS, filed on October 16, 1998, incorporated by reference herein in its entirety.
The present application is related to a co-pending U.S. Patent Application No. (Attorney Docket #22074661-25532) entitled METHOD FOR IMPACT ANALYSIS OF
A MODEL, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
The present application is related to co-pending U.S. Patent Application No. (Attorney Docket #22074661-25531} entitled METHOD FOR DETERMINING
DIFFERENCES BETWEEN TWO OR MORE MODELS, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
The present application is related to co-pending U.S. Patent Application No. (Attorney Docket #22074661-25533) entitled METHOD AND SYSTEM FOR AN
EXTENSIBLE MACRO LANGUAGE, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
The present application is related to co-pending U.S. Patent Application No. (Attorney Docket #22074661-25534) entitled METHOD AND APPARATUS FOR
PROVIDING ACCESS TO A HIERARCHICAL DATA STORE THROUGH AN
SQL INPUT, being concurrently filed on the same day, which is incorporated by reference herein in its entirety.
Reference To Paper Appendix The present application includes a paper appendix attached hereto setting forth exemplary services and functions for an exemplary embodiment of the present invention which is hereby incorporated by reference. A
portion of the disclosure of the.present application includes material which is subject to copyright 5 protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent disclosure, as it appears in the Patent & Trademark Office patent files or records, but otherwise reserves all copyright rights whatsoever.
Field Of The Invention The present invention relates to a modeling engine, in particular to an apparatus and method for building modeling tools.
Background Information 15 Modeling tools have existed for many years. The general method of implementing such modeling tools is to write a specific modeling tool that implements a specific modeling methodology. Although this method has generally been accepted, such a method has several 20 disadvantages. For example, conventional modeling tools require a new implementation for the creation of each new modeling tool, even though many functions within a given tool are similar, if not the same, as prior tools.
A need exists for a method and apparatus for 25 building modeling tools using a uniform framework constructed to support the generation of multiple, disparate modeling methodologies. This new apparatus and method for building modeling tools will reduce the effort and time required to implement a new modeling 30 tool.
Summary Of The Invention An aspect of the present invention is providing a method and apparatus that includes semantics and a model having objects and properties. Semantics are applied against transactions that change objects and properties that may be included in the model. Any changes to the objects and properties by a transaction that violates the respective semantics are undone. Further, the semantics may be extended by a developer.
Another aspect of the present invention provides an apparatus for building a modeling tool. The apparatus includes, for example, a meta model that has a semantic registry and a meta data manager, an object/property interface, and an object/property factory registry. The object/property factory registry is coupled to the meta model and the object/property interface. The apparatus also includes an object/property model coupled to the object/property interface.
Yet another aspect of the present invention provides a method for building a modeling tool. The method includes constructing an object/property model by defining a first set of classes and constructing a meta model by defining a second set of classes. The method also includes associating a type code with the first and second set of classes and providing a predefined set of semantics to the meta model. The method further includes identifying a plurality of discrete events with at least one semantic of the set of semantics being invoked at each occurrence of the plurality of discrete events. The method also includes providing an object/property interface for limiting access to the object/property model from a developer.
Brief Description Of The Drawings FIG. 1 illustrates a functional block diagram of a conventional computer system.
FIG. 2 illustrates a functional block diagram of an exemplary embodiment of the present invention.
FIG. 3 illustrates a data model of an exemplary embodiment of a meta model of the present invention.
FIG. 4 illustrates a flow diagram of an exemplary embodiment of a method of firing-an object semantic of the present invention.
FIG. 5 illustrates a flow diagram of an exemplary embodiment of a method of firing a property semantic of the present invention.
FIG. 6 illustrates a flow diagram of an exemplary embodiment of a method for building a modeling tool of the present invention.
FIG. 7 illustrates a flow diagram of an exemplary embodiment of executing an exemplary function of the present invention.
Detailed Description FIG. 1 illustrates a conventional computer system 101 in which the present invention operates. In an exemplary embodiment, the present invention is implemented, for example, on a SUNT"" Workstation manufactured by SUN MICROSYSTEMS'"'. Alternate embodiments may be implemented, for example, on an IBM' Personal Computer manufactured by IBM Corporation or a MACINTOSHT"" computer manufactured by APPLE"" Computer. It will be apparent to those of ordinary skill in the art that other computer system architectures may also be employed. In general, such computer systems as illustrated by FIG. 1 include a bus 102 for communicating information, a processor 103 such as a central processing unit coupled to the bus 102 for processing information, and a main memory 104 coupled to the bus 102 for storing information and instructions for the processor 103. A read-only memory 105 is coupled to the bus 102 for storing static information and instructions for the processor 203. A display device 106 coupled to the bus 102 displays information, for example, for a developer.
An alphanumeric input device 107, such as a key board, is coupled to the bus 102'and communicates information and command selections to the processor 103.

5 A modem 110 is coupled to the bus 102 and provides communication with, for example, other computer systems or databases and a mass storage medium 108, such as a magnetic disk and associated disk drive coupled to the bus 102 for storing information and instructions. A
10 data storage medium 109 containing digital information is configured, for example, to operate with a mass storage medium 108 to allow processor 103 access to the digital information on data storage medium 109 via bus 102. In addition, a CD-ROM drive (not shown) may also 15 be used for the storage of high resolution images for display on the display device 106.
An embodiment of the present invention is implemented, for example, as a software module written in the C++ programming language which may be executed on 20 a computer system such as computer system 101 in a conventional manner. Using well known techniques, the application software may be stored on data storage medium 109 and subsequently loaded into and executed within the computer system 101. Once initiated, the 25 software of the preferred embodiment operates, for.
example, in the manner described below. Universal Modeling Architecture (UMA) is a data-driven modeling engine that could work in various problem domains based on an external definition of a meta model that may be 30 provided by a developer and be extended to provide an UMA-based product. An external definition of a meta model is, for example, a series of descriptions of the types of objects that are to be found in the problem domain, and the properties associated with each of these objects. These descriptions may be provided by invoking a set of functions exposed by the implementation, and passing in, via function parameters, the descriptive information. Exemplary problem domains may include:
5 data modeling such as database tables, columns and indices; process modeling such as activities and arrows;
access modeling such as data manipulation language statements and files; and component modeling such as interfaces, implementations, and dependencies.
10 In an exemplary embodiment of the present invention, the UMA-based product is a modeling tool.
The UMA-based product may be an UMA-based application such as a user interface that includes UMA. The UMA-based product may also include an instance of an 15 object/property model based on an external definition of the meta model provided by, for example, a developer.
In an exemplary embodiment of the present invention, as shown in FIG. 2, UMA 200 includes a meta model 210, object and property factory registries 260, 20 object/property interface 280, transaction manager 285, log file 295, and object/property model 290. The meta model 210 may include a semantic registry 220 including a plurality of sets of semantics 230 and a meta data manager 240 including object/property descriptions 250.
25 The object/property descriptions 250 are sets of information describing the characteristics of an object or a property. In the case of objects, this may include its name, a human-readable piece of descriptive text, generalization information, information about what other 30 types of objects may be contained within it.
Generalization information, for example, describes refinement/subtyping such as synonyms information.
Object/property descriptions may be provided by the developer or user as the externally defined meta model.

The meta model 210 is a description of the objects and properties of the problem domain to be solved and a plurality of sets of semantics 230 to be respectively invoked to change objects and properties when changes to such objects and properties are requested.
FIG. 3 shows an exemplary embodiment of meta model 210 of the present invention. As shown in FIG. 3, the meta model 210 includes a plurality of classes such as objects, properties and semantics and establishes 10 relationships between objects, properties and semantics.
Type 310 is associated with a type code key, name attribute and definition attribute. Type 310 can be, for example, a category 330 or an item 320. Category 330 is associated with a type code key and includes a 15 plurality of items. Category membership 340 is associated with a category key and member key. Item 320 is associated with a type code key and can be a property or object.
Property 350 is associated with a type code key, 20 default value attribute and datatype attribute.
Property 350 is also associated with property usage 375.
Object 360 is associated with a type code key, object implementation attribute, and supertype attribute. A
supertype attribute provides further specificity to the 25 object 360. Object 360 may own (e.g., include as a component) and be owned by other objects. Object ownership 370 is associated with owner key and ownees key. Property usage 375 is associated with property key and object key.
30 Property usage 375 also associates the property 350 with the object 360. Object semantic usage 390 is associated with a type code key and identification (ID) key. Object semantic usage 390 associates object 360 with object semantic 395. The object semantic 395 is associated with an ID key. Property semantic usage 380 is associated with an ID key, property key and object key. Property semantic usage 390 associates property semantic 385 with property usage 375. Property semantic 385 is associated with an ID key.
As shown in FIG. 2, the meta data manager 240 of the meta model 210 receives meta data (e. g., description of objects and properties), for example, from a developer through an UMA-based application 225. The 10 meta data is what are the objects and properties provided by a developer to solve the problem domain of the developer. The meta data manager 240 receives validation creation requests from object and property factory registries 260.
15 As shown in FIG. 2, the semantic registry 220 of the meta model 210 includes a plurality of sets of semantics 230 which may include, for example, a predefined set and additional sets provided by the developer through an UMA-based application. Semantics 20 230 are modeling rules encapsulated in semantic objects that expose an interface, such as a pure virtual class, that hide the modeling engine from details of the semantics 230. The predefined semantic set provides rules to enforce the integrity of the underlying 25 modeling engine and in an exemplary embodiment of the present invention, the predefined semantic set cannot be changed by a developer. The additional sets of semantics provided by the developer can be modified by the developer. An example of a semantic may be, for 30 example, one that enforces the rule "No two columns in a single database table may have the same name."
Semantics 230 gain access to object/property model 290 through object/property interface 280. The semantic registry 220 may include an object semantic registry for determining if a specific set of object semantics exist and, if so, locating respective sets of object semantics. The semantic registry 220 may also include a property semantic registry for determining if a specific set of property semantics exist and, if so, locating the respective set of property semantics. The semantic registry 220 locates the respective set of semantics requested, for example, by object/property interface 280. The semantic registry 220 makes changes to the respective objects and properties in accordance with the semantics invoked and provides the changed objects and properties to object/property interface 280. The semantic registry 220 also provides the status of an action of a transaction to the object/property interface 280. For example, one of the semantics invoked for an action may be violated and, thus, indicate that the action has failed.
Object and property factory registries 260 may include factories 270 such as object factories and property factories, respectively. The object and property factory registries 260 receive requests for the creation of objects and properties, for example, from a developer through an UMA-based application 225. The factories 270 create objects and properties. The object and property factory registries 260 determine if a specific factory exists and, if so, locate the respective factory to create the respective object or property being requested. The object and property factory registries 260 also provide a validation creation request to the meta data manager 240. The validation may include, for example, whether the ' creation of the object or property requested was successful. The object and property factory registries 260 instantiate objects and properties, respectively, and provide such objects and properties to object/property interface 280.
As shown in FIG. 2, object/property interface 280 receives requests for the modification and deletion of 5 objects and properties, for example, by a developer through UMA-based application 225. Such requests invoke the respective semantics in meta model 210 which may result in changes to the objects and properties which are provided to object/property interface 280 from 10 semantic registry 220 of meta model 210. The object/property interface 280 may identify a discrete event from a plurality of discrete events, for example, as shown in Table One, and determine that a semantic or set of semantics should be invoked. The discrete events 15 indicate occurrences where object/property model 290 may be modified. In an exemplary embodiment of the present invention, authors of UMA may provide a plurality of discrete events.

TABLE ONE
Constant ~ Description PostCreation An object is being created PreDestruction An object is being destroyed PreEdit A property is about to be created and/or modified PostEdit A property has just been created and/or modified PreNull A property is about to be destroyed PreOwnerDestruction The object owning a property is about to be destroyed The object/property interface 280 is provided with 5 the status of an action of a transaction by semantic registry 220 based on the result of the respective set of semantics invoked. For example, if an action caused any one of the set of semantics invoked to be violated, semantic registry 220 may provide an indication that the 10 action failed. If the action did not cause any one of the set of semantics to be violated, however, semantic registry 220 may provide an indication that the action was successful. The object/property interface 280 provides object and property changes to the transaction 15 manager 285 and, if the object/property interface 280 determines that an action failed, it may provide an indication that the action failed to transaction manager 285. The object/property interface 280 also provides objects and properties to object/property model 290.
The object/property 280 interface also retrieves objects and properties from object/property model 290, for example, to provide such objects and properties to an UMA-based application 225 if requested.
FIG. 4, illustrates a flow diagram of an exemplary method of object/property interface 280 firing an object semantic. In 410, the object/property interface 280 opens transaction with transaction.manager 285. A
10 transaction is opened for each change to the model so that the change can be cancelled if: found to be invalid.
In 415, object/property interface 2.80 communicates with the object itself. All objects know their type to determine the object type. In 420, object/property 15 interface 280 obtains the complete supertype path for a respective object from meta model 210, for example, in top-down order. In 425, the first object type (ultimate supertype) is obtained by object/property interface 280 from the metamodel.
20 In 430, object/property interface 280 obtains the semantic list for the object type from object semantic registry 220. In 435, object/property interface 280 communicates with semantic registry 220 to determine whether more semantics are in the list. If yes, 25 object/property interface 280 obtains, in 455, and .
fires, in 460, the next semantic. The object/property interface 280 determines, in 465, if the semantic failed. If so, in 470, the transaction is rolled back by the transaction manager 285 pursuant to a request 30 from object/property interface 280. If, however, the semantic did not fail, in 435, object/property interface 280 will again determine whether any more semantics are in the list.
If no more semantics are in the list, in 440, object/property interface 280 will communicate with the metamodel and determine whether any more object types are in the ancestry path. If no; in 450, the transaction is committed. If there are more object 5 types in the ancestry path, in 445, the next object type is obtained and object/property interface 280 again proceeds in 430 with obtaining the semantic list for object type from object semantic registry.
FIG. 5 illustrates a flow diagram of an exemplary method of object/property interface 280 firing a property semantic. In 510, object/property interface 280 opens the transaction with transaction manager 285.
In 515, object/property interface 280 communicates with the object to determine the object type. In 520, 15 object/property interface 280 obtains the complete supertype path for the respective object from meta model 210, for example, in top-down order. In 525, the first object type (ultimate supertype) is obtained by object/property interface 280 from the metamodel. In 20 527, object/property interface 280 constructs an object/property pair for object and property types. In 530, object/property interface 280 obtains the semantic list for the object/property pair type from property semantic registry 530.
25 In 535, object/property interface 280 determines whether more semantics are in the list. If yes, in 555, object/property interface 280 obtains the next semantic and in 560 fires the next semantic. In 565, if object/property interface 280 determines that the 30 semantic failed, in 570, the transaction is rolled back.
If, however, the semantic did not fail, object/property interface 280 will return to 535 to determine whether any more semantics are in the list.
If no more semantics are in the list, in 540, object/property interface 280 will communicate with the metamodel and determine whether any more object types are in the ancestry path. If no; the transaction is committed in 550. If there are more object types in the 5 ancestry path, in 545, the next object type is obtained and object/property interface 280 again proceeds with constructing an object property pair for object and property types in 527.
In an exemplary embodiment of the present 10 invention, object/property model 290 includes a set of predefined objects and properties. The predefined set of objects and properties may be provided by, for example, the UMA developer to decrease the amount of work necessary for the developer o:~ the product. The 15 object/property model 290 also receives objects and properties from an object/property interface 280. The objects and properties received from the object/property interface are based on the external definition of the meta data provided by the developer. It is the objects 20 and properties requested, for example, by a developer to be created and modified that are included in object/property model 290. Further, the object/property model 290 logs model changes to the transaction manager 285 through an object/property interface 280. In an 25 exemplary embodiment of the present invention, however, objects and properties in object/property model 290 that are a result of a failed action are removed from object/property model 290.
Accordingly, in an exemplary embodiment of the 30 present invention, objects and properties provided by a developer that remain in the object/property model 290 are the objects and properties that result from a successful action. Thus, a developer does not have direct access to and cannot directly change the object/property model 290. Consequently, changes to the model are known by the modeling engine and consistent and valid states can be assured ~t all times. If the developer had direct access to the underlying data 5 structures, inappropriate changes may be made thereby creating invalid states in the model.
The transaction manager 285 places respective objects and properties in the state that they were in prior to being changed by a failed action. For example, l0 the transaction manager 285 is provided with the indication that an action has failed by the object/property interface 280. Any action that fails is undone or wiped out. The transaction manager 285 may accomplish this, for example, by logging changes of 15 object/property model 290 to log file 295, obtaining undo data from the log file 295, and performing an undo operation based on the success or failure of actions within a transaction as determined by object/property interface 280. Accordingly, object/property model 285 20 is maintained in a valid state. I:n an exemplary embodiment of the present invention, transaction manager 285 may also receive a request to undo or redo an action from UMA-based application 225. If a redo is being requested, transaction manager 285 may request redo 25 information from log file 295 and perform the redo operation an a known manner.
In an exemplary embodiment of the present invention, UMA 200 may further include an internal services component and an external. services interface.
30 The internal services component may include, for example, services or functions exposed to the developer to assist in the creation and manipulation of a model for solving the problem domain of the developer. In an exemplary embodiment of the present invention, internal WO 00/23$83 PCT/US99/24118 services may include those services or functions indicated in Appendix 1 attached herein.
The external services intergace is an interface which allows external services to communicate with UMA
200. The external services interface may be, for example, an object linking and embedding an add-in application program interface allowing third-party modules to extend the modeling capabilities of the tool, thus extending the modeling environment and the modeling 10 rules to include functionality such as being automatically user-defined. Accordingly, the developer may have access to services beyond the services internal to UMA 200. External services may be, for example, a module for enforcing corporate naming standards upon all 15 names entered by the user. Further, UMA 200 is scalable as the user interface such as UMA-based application 225 is separated from the semantics 230.
An exemplary embodiment of a method for building modeling tools of the present invention is shown in FIG.
20 6. In 610, an object/property model 290 is constructed by defining a first set of classes for objects and properties provided by the developer as meta data. In an exemplary embodiment of the present invention, the object/property model 290 may include a predefined set 25 of one or more objects and properties. The objects provide storage mechanisms for the properties that apply to it. In an exemplary embodiment of the present invention, an interface class for an object may be, for example, UMEObjectI. Properties may be implemented as a 30 base class that requires programmer subclassing. In an exemplary embodiment of the present invention, the base class may provide administration services without data storage. In an exemplary embodiment of the present invention, a developer may provide a subclass that declares the data element and a method for creating an accessor.
In 620, a meta model 210 is constructed, for example, by defining a second set of classes. The second set of classes are designed to hold descriptions of properties, objects and semantics. For example, in an exemplary embodiment of the present invention, two semantic interface classes are specified. A first semantic interface class, for example, UMEObjectSemanticl, is the interface for any semantic that affects the creation or destruction of an object.
Further, a second semantic interface class, for example, UMEPropertySemanticI, is the interface for any semantic that affects the creation, destruction, or modification of a property. In an exemplary embodiment of the present invention, the implementation of a representation of meta model 210 includes a singleton object that exposes static methods for registering meta data and semantics.
Modeling rules, e.g., semantics 230, may be incorporated into semantic registry 220 of meta model 210 as a predefined set of semantics as in 640 and/or as additional sets of semantics, for example, provided by a developer either upon startup or any time thereafter.
In order to incorporate a modeling rule into meta model 210 for an object., the developer subclasses the appropriate calls, for example, UMEObjectSemanticI for a modeling rule for an object and UMEPropertySemanticl for a modeling rule for a property. The developer also could implement a fire method to perform the desired operations and checks upon object/property model 290. A
value will be returned to indicate whether the operation was successful. For example, a return value of TRUE
would indicate that the operation was successful, and a return value of FALSE would indicate that the operation could not be performed successfully or that the model was in an invalid state. Access-points (e. g., object/property model modification points) may also be included in meta model 210 for invoking semantics 230.
The various model modification points (e. g., CreateObject) would invoke the respective semantic at the appropriate point. If an indication is received from the firing of semantics that one or more semantics had failed to complete successfully, for example, FALSE, the operation could then abort.
In 630, a type code is associated with the first and second set of classes. A type code is a unique identifier that specifies what type of meta data is being represented. Each item specified in the meta model, both objects and properties, would have a unique type code. In an exemplary embodiment of the present invention, UMA 200 includes a variable type, TypeCode t, which is declared to hold the type codes. A predefined set of semantics is provided to the semantic registry 220 of meta model 210 in 640.
In 650, a plurality of discrete events, for example, as shown in Table One, are identified. The discrete events indicate occurrences where object/property model, 290 may be modified. In an exemplary embodiment of the present invention, each discrete event is assigned a constant to represent it, and a variable type, for example, Event t, is declared to hold the event constants.
In 660, object/property interface 280 is provided.
The object/property interface 280, for example, prevents a developer from directly accessing object/property model 290 and may include limiting the number of code paths by which a developer could modify object/property model 290. For example, if a developer wanted to destroy an object in object/property model 290, a request would have to be made to object/property interface 280 such as UMEObjectI:DestroyObject as listed in Appendix 1.
FIG. 7 shows an exemplary embodiment of object/property interface 280 executing DestroyObject request. As shown in FIG. 7, access to object/property model 290 is limited by object/property interface 280 handling the DestroyObject request. For example, in 710, object/property interface 280 r_ommunicates with transaction manager 285 to open a transaction upon receiving a request to destroy an object (e. g., DestroyObject function). In 715, object/property interface 280 communicates with object/property model 290 to find the object requested to be destroyed. In 720, object/property interface 280 determines whether the object was found. If not, in 725, transaction manager 285 rolls back the transaction pursuant to a request by object/property interface 280 and in 730 transaction manager returns a failure code to the calling module, for example, the user interface. If the object is found, however, in 735, object/property interface 280 provides transaction manager 285 with the object destruction information and transaction manager 285 logs the object destruction into transaction log 295.
In 740, object/property interface 280 fires the PreOwnerDestruction Semantics on all properties of the respective object. In 745, object/property interface 280 determines whether all semantics succeeded. If not, in 725, transaction manager 285 rolls back the transaction pursuant to a request by object/property interface 280 and 730 transaction manager returns a failure code to the calling module.
If all the PreOwner Destruction Semantics succeeded, in 750, object/property interface 280 fires the PreDestruction Semantics. In 755, object/property 5 interface 280 determines whether all of the PreDestruction Semantics succeeded. If so, in 760, the object is destroyed, in 765, object/property interface 280 communicates to transaction manager 285 to end transaction, and in 770, 730, transaction manager 285 10 returns a success code to the calling module. If the PreDestruction Semantics failed, however, in 725, transaction manager 285 rolls back transaction pursuant to a request from object/property interface 280 and 730, and transaction manager 285 returns a failure code to 15 the calling module.
To limit construction and destruction of objects, for example, object constructors and destructors are protected to prevent the developer from directly instantiating or destroying an object. To limit the 20 creation, destruction and modification of properties, for example, the data members of the properties are made private. In an exemplary embodiment of the present invention, UMA 200 includes a class known as an accessor that includes an interface class, for example, 25 UMEAccessorI. The accessor interface class is a friend class to the property and it is through accessors that access is gained to the data members. Accessors are "
provided with data values and instructions (e.g., set the value" or "delete the property") and injected into 30 properties. Accessors perform their actions and return a code indicating success or failure. Accessors are constructed by asking the property to provide one. This allows the property to construct an accessor that can handle the data type of the property. All operations on a property are conducted via an accessor, thus any code that the semantics require could be placed in the accessor base class that is supplied. The developer subclassing accessor would simply provide a data element and a way of reading and writing to it. Methods are provided on the accessor base class to allow the binding to a property.
As shown in FIG. 6, in 670, a transaction manager 285 is provided. The transaction manager 285 manages l0 actions of a transaction and if the actions fail, the actions are undone or are wiped out. By starting a transaction at the beginning of a model manipulation, then monitoring the error states of the various semantics, the transaction manager 285 maintains the object/property model 290 in a valid state. In an exemplary embodiment of the present invention, transaction manager 285 records an exact image of object/property model 290 prior to the implementation of a change based on an action. If the action succeeds, the respective change is allowed to stand. If a failure occurs, then transaction manager 285 restores the old image. The transaction manager 285 may incrementally preserve images as the model changes.
As an example, within a single transaction the user is going to create an object and set its name. Upon successful creation of an object, the fact that the object was created and a handle to that object are stored in the transaction log 295. If the user then sets the name of the object to "Customer," the creation of the property is recorded and the old value (nothing) is saved to the log. If the user then sets the name again to "Cust," the old value ("Customer") is saved to the log. If all succeeds, then an object named "Cust"
exists. On failure, however, transaction manager 285 will start rolling back: first, changing the name from "Cust" to "Customer"; second, deleting the existence of the name property altogether; and.finally, deleting the object. This restores object/property r~iodel 290 to the state that existed prior to the performance of the failed transaction.
In an exemplary embodiment of the present invention, the changed objects and properties as a result of an action are provided to object/property model 290 by object/property interface 280. If the semantics involved by the action fail, object/property interface 280 informs transaction manager 285 to undo the action. As a result, object/property model 290 is placed back in the state prior to the changed objects and properties being provided to the object property model 290 from the object/property interface 280 as a result of the failed action.
The embodiments described above are illustrative examples of the present invention and it should not be construed that the present invention is limited to these particular embodiments. Various changes and modifications may be effected by one skilled in the art without departing from the spirit or scope of the invention as defined in the appended claims.

WO 00/23883 PCTlUS99/24118 (~p~ehd, x 1.1.1 Unbound Functions M~tamodelReadlnferface Description Retrieves the rcad interface on the singleton metamodel instance.
Signature extern "C"
UMEMetaModelReadl * MetamodelReadlnterface( void ) Parameters Name Type Description <return> R The read interface to the UMA metamodel.
MetamodelWrltelnterface Description Retrieves the write interface on the singleton metamodel instance.
Signature extern "C"
UMEMetaModelReadI * MetamodelWritelnterface( void ) Parameters Name Type Description <retum> R The write interface to the UMA metamodcl.
MetamodelUselnterface Description Retrieves the use interface on the singleton metamodel instance.
Signature extern "C"
UMEMetaModelReadI * MetamodelUscInterface( void ) Parameters Name Type Description <retutn> R The use interface to the UMA metamodel.
1.1.2 UMEReferenceCountedl Interface for.reference. counted objects. Several of the other interfaces extend this one. Conceptually, a reference-counted object should free itself from memory when its count hits zero. In practice, this is up to the implementing object and it may simply return itself to a pool.

WO 00/23883 Ptr'T/US99/24118 A~~Refe~nce Description Increments the reference count.
Signature void UMEReferenceCountedI::AddReference( void ) RemoveReference Description Decrements the reference count.
Signature void UMEReferenceCountedI::RemoveReference( void ) 9.1.3 UMEPublisheri The publisher side of a publish/subscribe pair.
Subscribe Description Adds/removes a subscriber tolfrom the list otobjects to notify.
Signature Return t UMEPublisherl::Subscribe( UMESubscriberI ' Subscriber, bool Activate ) Parameters Name Type Description <retutn> R The error code for the calf Subscriber I The subscriber to notify of events Activate I True to add a subscription, False to remove a subscription 9.1.4 UMESubscriberl The subscriber side of a publish/subscribe pair.
Notlfy Description The callback used by the publisher to notify the subscriber of events.
Signature void UMESubscriberI::Notify( UMEPublisherI' Publisher, UMEEventI' Event ) Parameters WO 00/23$83 PCT/US99/24118 Name Type Description Publisher I Who is sending the event notification Event I The event notification 1.1.5 UMEEventl Extends: UMEReferenceCountedI
Events sent between a publish/subscribe pair. Subscribers must increment the reference count in their Notify method if they want to maintain access to the event; the publisher will remove his reference count upon completing the notifications.
1.1.6 UMEValuei Provides base interface for data type wrappers. Data type wrappers are used when data values need to be passed to the metamodel (e.g. valid valid lists).
1.1.7 UMEMetamodelReadl Interface for querying the metamodel. Though UMA 2.0 implements the metamodel as a C++ singleton using static methods, this interface exists to allow other components to standardize on a queriable interface.
BuiIdVersion Description Retrieves the build number.
Signature LWTString UMEMetamodelReadL:BuildVersion( void ) Parameters Name Type Description <return> R The version string for the DLL
ConstructSignature Description Constructs a specified signature for the specified object.
Signature Return t UMEMetamodelReadI::ConstructSignature( UMEObjectI * Object, const SignatureGeneratorId t & Generator, LWTString & Signature ) Parameters Name Type Description q~~n,> R The error code for the call Object I The object for which signatures are desired Generator I The specific generator to be employed Signatures O The signature ConstructSignatures Description Constructs all signatures for the specified object. The returned array will always have the same number of elements are there are registered signature generators. If a signature generator does not support a given object type, then its entry will be an empty string.
Signature Retum_t UMEMetamodelReadI::ConstructSignatures( UMEObjectI' Object, LWTOrderedVectorT<LWTString> & Signatures ) Parameters Name Type Description <return> R The error code for the call Object I The object for which signatures are desired Signatures O The signatures GetClipFlags Description Retrieves the clipboard flags associated with the objectlproperty pair.
Signature Return t UMEMetamodelReadI::GetClipFlags( TypeCode t Object, TypeCode~t Property, CIipFlags t & ClipFlags ) Parameters Name Type Description <retum> R True if registered Object I The typecode for the object Property I The typecode for the property CIipFlags O The clip flags GetDafa~ype Description Retrieves the typecode of property's data type.
Signature Return t UMEMetamodelReadL:GetDatatype( TypeCode t Code, TypeCode t &
Datatype) Parameters Name Type Description <return> R The error code for the call C~a I The typecode for the property Datatype O The typecode for the data type GetDeffnlfion Description Retrieves the definition stored in the metamodel of an item.
Signature Return t UMEMetamodelReadI::GetDatatype( TypeCode t Codc, LWTString &
Definition) Parameters Name Type Description <retum> R The error code for the call Code I The typecode for the item Definition O The definition GetEntr7rSubscribers Description Retrieves the list of subscribers who are registered to receive notification upon destruction of a metamodel entry.
Signature Return_t UMEMetamodelReadI::GetEntrySubscribers( TypeCode t Code, LWTOrderedVectorT<I'ypeCode t> & Subscribers ) Parameters Name Type Description <retum> R The error code for the call Code I The typecode for the entry Subscribers O The subscribers currently registered GefFlaas Description Retrieves the metamodel'flags on an item.
NB: TheseJlags should not be confused with Jhe item Jlags returned by UMEObjecJl:: Flags() or UMEPropertyL: FIagsQ.
Signature Return t UMEMetamodelReadI::GetPlags( TypeCode~t Code, MetamodelFlags t &
Flags ) Parameters Name Type Description ~etum> R The error code for the call Code I The typecode for the item Flags O The metamodel flags GetlnheritableProperties Description Retrieves the typecodes of the properties that can be inherited for the specified object type.
Signature Retum_t UMEMetamodelReadI::GetInheritableProperties( TypeCode t Code, LWTOrderedVectorT~fypeCode t> & Properties) Parameters Name Type Description <return> R The error code for the call Code I The typecode for the object Properties O An array of the inheritable property typecodes Getltert~Slze Description Retrieves the size of the item in bytes.
Signature Return t UMEMetamodelReadI::GetItemSize( TypeCode t Code, size t d: Size ) Parameters Name Type Description <return> R The error code for the call Code I The typecode for the item Size O The size of the item as defined by its factory GetObyectTypes Description Retrieves the typecodes of the objects that are defined for the specified product. The result is filtered by the various flag fields.
Signature Return t UMEMetamodclReadI::GetObjectTypes( MetamodelFlags t FIagsOn, MetamodelFlags t FlagsOff, const Productld t & Product, MetamodelFlags~t ProductFlagsOn, MetamodelFlags t ProductFlagsOff, LWTOrderedVectorT<fypeCode t> & Objects ) Parameters Name Type Description <return> R The error code for the call FlagsOn I Flags that must be set for the object to be included FlagsOff I Flags that must not be set for the object to be included Product I An identifier for a product.
Passed as a reference due to size.

ProductFlagsOn I Product-specific flags that must be on for the object to be included.

ProductFlagsOff I Product-specific (lags that must not be on for the object to be included.

Objects O The object typecodes matching the criteria GetOwneeTypes Description Retrieves the typecodes of objects that may be owned by the specified object.

Signature Return t UMEMetamodelReadI::GetOwneeTypes( TypeCode t Code, LWTOrderedVectorT~fypeCode t> & Ownees ) Parameters Name Type Description <retum> R The error code for the call Code I The typecode for the object Ownees O An array of the ownee typecodes GetOwnerTypes Description Retrieves the typecodes of objects that may serve as the owner of the specified object.
Signature Return t UMEMetamodelReadI::GetOwnerTypes( TypeCode t Code, LWTOrderedVectorT<TypeCode~t> & Ownerx ) Parameters Name Type Description ~atmn> R The error code for the call Cods I The typecode for the object Owners O An array of the owner typecodes GetPro~~yTvpes Description Retrieves the typecodes of the properties that are defined for the specified product. The result is filtered by the various flag fields.

Signature Return t UMEMetamodelReadI::GetPropertyTypes( MetamodelFlags t FIagsOn, MetamodelFlags t FlagsOff, Productid t & Product, MetamodelFlags_t ProductFlagsOn, MctamodelFlags t ProductFlagsOfF, LWTOrderedVectorT<I"ypeCode t> & Properties ) Parameters Name Type Description <return> R The error code for the call FlagsOn I Flags that must be set for the property to be included FIagsOfi' I Flags that must not be set for the property to be included Product I An identifier for a product.
Passed as a reference due to size.

ProductFlagsOn I Product-specific flags that must be on for the property to beincluded.

ProductFlagsOfi' I Product-specific flags that must not be on for the property to be included.

Properties O The property typecodes matching the criteria GetProperfjrUsagies Description Retrieves the list of property types that can be set on the specified object.
Signature Retum_t UMEMetamodelReadI::GetPropertyUsages( TypeCode t Code, LWTOrderedVectorT~fypeCode~t> & Usages ) Parameters Name Type Description <return> R The error code for the call Code I The typecode for the object Usages O An array of the property typecodes GetSubtypes Description Retrieves the typecodes of subtypes of the specified object.
Signature Return t UMEMetamodelReadI::GetSubtypes( TypeCode t Code, LVJTOrderedVectorTn'ypeCode t> & Subtypes ) Parameters Name Type Description <return> R The error code for the call Code I The typecode for the object Subtypes O An away of the subtype typecodcs GetS~rpertype Description Retrieves the typecode of the immediate supertype for the specified object.
Signature Return~t UMEMetamodelReadL:GetSupertype( TypeCode t Code, TypeCode t &
Supertype ) Parameters Name Type Description <return> R The error code for the call Code I The typeeode for the object Supertype O The supertype typecode lslnherltable Description Determines if the specified property is inheritable for the specified object.
Signature boolean UMEMetamodelReadI::IsInheritable( TypcCode t Object, TypeCode t Property ) Parameters Name Type Description <return> R True if inheritable Object I The object's typecode Property I The property's typecode IsReglstered DescrIptlon Determines if the specified typccode is registered with the mctamodel.
Signature boolean UMEMetamodelReadI::IsRegistered( TypeCodc t Code ) Parameters Name Type Description <r~~> R True if registered I The typecode for the item IsUserDefined Description Deterntines if the specified typecode is was registered by the user or Add-In code...i.e. is it a UDP
or UDO?
Signature boolean UMEMetamodelReadI::IsUserDetined( TypeCode t Code ) Parameters Name Type Description <return> R True if user-defined Code 1 The typecode for the item Lookup Description Provides translations benveen typecodes and names of metamodel entries. The name provided or read will be interpreted through the nomenclature specified.
Signature Variant A: TypeCode_t UMEMetamodelReadL:Lookup( const LWTString d: Name, NomenclatureId t & Nomenclature ) Variant B: LWTString UMEMetamodelReadI::Lookup( TypeCode t Code, NomenclatureId t & Nomenclature) Parameters Name Type Description <retum> R Variant A: the typecode associated with the name Variant B: the name associated with the typecode Name I A name for the metamodel entry Code I The typecode for the metamodel entry Nomenclature I An identifier for a nomenclature. Passed as a reference due to sine.
_ M2Type Description Determines what kind of metamodel entry con;esponds to the typecode. The return value will be one of the following UMEMetamodelReadI constants:

Constant Descrtptton kIsUnknown The typecode is not known to the metamodel kIsObjectImplementationThe lypecode represents an object implementation type kIsObject The typecode represents an object kIsPropettyDatatypeThe typecode represents a property data type kIsProperty The typecode represents a property kIsCategory The typecode represents a category Signature long UMEMetamodelReadI::M2Type( TypeCode t Code ) const Parameters Name Type Description <retum> R A constant indicating the M2 type of the typecode Code I The typecode to be checked Resolveld Description Converts an object id to a pointer to the object.
Signature Variant A: UMEObjectl * UMEMetamodelReadI::ResolveId ( Id t Id ) Variant B: UMEObjectt * UMEMetamodelReadI::ResolveId( ObjectId_t Id ) Parameters Name Type Description <return> R A pointer to the object having the specified id, NULL if not found.
Id 1 The object's id 1.1.8 UMEMetamodelWritel The write interface generally support two variants for each of the registration methods. One variant uses primitive C++ types, such as const char * and Typeeode t *. The second variant uses wrapper class such as const LWTString & and const LWTOrderedVectorT<TypeCode t> &. The former type is faster to construct, but more dangerous, and is intended for the code generated by MMGen.exe. The latter can be somewhat slower due to the need to construct the wrapper and container classes, but is safer, and is intended for "hand coding"
1h Applies To O O P P C

b b r r a j j o o t a a p a a c c a p g t t t r o I y t r m D y y kSequcnceImportant J The sequence of values in the property is significant and must be maintained.

kPreFetchType ~/ The property starts as a PreFetch property kCalculated ~/ The property has a value that is calculated by semantics and should not be set by user.

kPersistenceUnit J The,object is a persistence unit.

kWorkspace J The object is a workspace.

kStrict ~/ The property may contain only those values found in the valid values list.

DefaultSemanticPackaae Description Retrieves the default semantic package built into the metamodel. This package is used to hold those semantics necessary for the modeling engine to function, as well as any the user wishes to add.
Signature UMF.SemanticPackageI & UMESemanticPackagel::DefaultSemanticPackage( void ) coast Parameters Name Type Description <retum> R The semantic package built into the metamodel RegisterCategorv Description Registers a new category in the metamodel. Any member typecodes supplied should already be registered with the metamodel. Additional members can be added at a later limo using UMEMetamodelWriteI::RegisterCategoryMembers.
The data passed in are copied into the metamodel; the source memory can be freed after this tail returns.
Signature Variant A: Return t UMEMetamodelWriteI::RegisterCategory( TypcCode t Code, coast Char t ' NameBufler, coast Char t' DescriptionBuffer, TypeCode t' MembersBuffer, MetamodelFlags t Flags Variant B: Return t UMEMetamodelWriteI::RegisterCategory( TypeCode_t Gode, coast LWTString & Name, coast LWTString & Description, coast LWTOrderedVcctorT<TypeCode t> & Members, MetamodelFlags_t Flags ) Parameters Name Type Description <retum> R The error code for the call I The typecode for the category N~t~ I The internal name for the category NameBuffer I A null-terminated buffer with the internal name for the category. All metamodel entries must have a name; a null pointer here will prevent registration.

Description 1 The description of the category DescriptionBufferI A null-terminated buffer with the description of the category. If no description is available, pass a null pointer.

Members I A list of the members' typecodes MembersBuffer I A list of the members' xypecodes.
This must terminate with an entry set to TypeCodes::Undefined.

Flags I Metamodel flags (see description above) ReglsterCa tegoryMembers Description Adds or subtracts members from an existing category. Member typecodes should already be registered with the metamodel.
The data passed in are copied into the metamodel; the source memory can be freed after this call returns.
Signature Variant A: Return_t UMEMetamodelWriteI::RegisterCategoryMembers( TypeCode t Code, TypeCode t * MembersBuffer, bool Add ) Variant B: Return t UMEMetamodelWritet::RegisterCategoryMembers( TypeCode t Code, const LWTOrderedVectorT~TypeCode t> & Members, boot Add ) Parameters Name Type Description <return> R The error code for the call Code I The typecode for the category Members I A list of the member typecodes MembersBuffer I A list of the members' typecodes. This must terminate with an entry set to TypeCodes::Undefined.
Add I Truc to add the members from the list, False to remove them ReglsterNomenclature Description Registers a nomenclature with the metamodel.
The data passed in are copied into the metamodel; the source memory can be freed after this call returns.
'13 Signature Retum_t UMEMetamodelWriteh:RegisterNomenclature( const NomenclatureId~t &
Nomenclature, const LWTString & Name ) Parameters Name Type Description <return> R The error code for the call Nomenclature I The id of the nomenclature Name I The name of the nomenclature ReqisterNom en cla tureEn tryr Description Registers an entry into a nomenclature.
The data passed iri are copied into the metamodel; the source memory can be freed afier this call returns.
Signature Return t UMEMetamodelWriteI::RegisterNomenclatureName( const T\'omenclatureld_t &
Nomenclature, TypeCode t Code, const LWTString 8. Name ) Parameters Name Type Description <retutn> R The error code for the call Nomenclature I The id of the nomenclature Code I The typecode of the metamodel item Name I The name to associate with the typecode ReaisterNomenclatureNart~es Description Allows bulk registration of names for a nomenclature. The buffer should contain alternating typecodes and null-terminated strings. The buffer must be terminated with the value TypeCodes::Undefined.
The data passed in are copied into the metamodel; the source memory can be freed after this call returns.
Signature Return t UMEMetamodclWriteI::RegisterNomenciatureNames( const NomenclatureId t &
Nomenclature, char * Buffer ) Parameters '14 Name Type Description <re~n> R The error code for the call Nomenclature I The id of the nomenclature Buffer I A buffer of typecode/null-terminated string pairs RegnsterObject Description Registers a new object in the metamodel.
The data passed in are copied into the metamodel; the source memory can be freed after this call returns.
Signature Variant A: Retum_t UMEMetamodelWriteI::RegisterObject( TypeCode_t Code, const Char t *
NameBuffer, const Char t * DescriptionBuffer, TypeCode_t Implementation, TypeCode t Supertype, TypeCode_t * OwnersBuffer, MetamodelFlags_t Flags, TypeCode t * UDOCode = NULL ) Variant B: Return_t UMEMetamodelWriteI::RegisterObject( TypeCode_t Code, const LWTString & Name, const LWTString ~. Description, TypeCode t Implementation, TypeCode t Supertype, const LW'TOrderedVectorT~fypeCode t> R. Owners, MetamodelFlags t Flags, TypeCode t * UDOCode = NULL ) Parameters Name Type Description <retum> R The error code for the call Code I The typecode for the object Name I The internal name for the object NameBuffer I A null-terminated buffer with the internal name Cor the object. All metamodel entries must have a name; a null pointer here will prevent registration.

Description 1 The description ofthe object DescriptionBufferI A null-terminated buffer with the description of the object.

If no description is available, pass a null pointer.

ImplementationI The typecode for the object implementation that his object will use Supertype I The supertype of the object Owners I The list of valid owners' typecodes for this object. All objects, except UOEnvirortment, must have at least one valid owner type.

OwnersBufferI The list of valid owners' typecodes for this object. All objects, except UOEnvironment, must have at least one valid owner type. The buffer must terminate with an entry set to TypeCodes::Undefined.

Flags I Metamodel flags (sec description above) UDOCode O Populated with typecode assigned to the UDO if Code is TypeCodes::Undefined.

RecrlsterOblec~lmr~l~ment~ on Descrlptlon Registers a new implementation for objects.
The metamodel does not assume responsibility for cleaning up factories-this allows these objects to be allocated off the heap or statically in the data segment. Instead, if a subscriber is provided, the metamodel will notify the subscriber when the entry for the property data type is destroyed;
the subscriber can take appropriate cleanup action at that time. All other information is copied into the metamodel and can be freed when this method returns.
SIgnature Variant A: Return t UMEMetamodelWriteI::RegisterObjectlmplementation( TypeCode t Code, coast Chart * NameBuffer, coast Char t * DescriptionBuffer, UMEObjectl=actoryI
*
Factory, MetamodelFlags t Flags, UMESubscriberI * Subscriber = NULL ) Variant B: Return_t UMEMetamodclWriteI::RcgisterObjectImplementation( TypeCode t Code, coast LWTString & Name, coast LWTString & Description, UMEObjectFactoryl *
Factory, MetamodelFlags t Flags, UMESubscriberI * Subscriber = NULL ) Parameters Name Typc Description <return> R The error code for the call Code 1 The typecode for the object implementation Name I The internal name for the object implementation NameBuffer I A null-terminated buffer with the interns! name for the object implementation. All metamodel entries must have a name; a null pointer here will prevent registration.

Description 1 The description of the object implementation DcscriptionBufferI A null-terminated buffer with the description of the object implementation. If no description is available, pass a null pointer.

Factory I The factory capable of constructing instances of the object implementation Flags I Metamodel flags (see description above) Subscn'ber I The subscriber to notify when this metamodel entry is dcsaoyed ReqlsterPronertv Description Registers a new property in the metamodcl. For application-defined properties, the typecode should be specified. To register a UDP, specify a typecode of TypeCodes::Undefined !or Code;
the assigned typecode will be placed in UDPCode.
The data passed in are copied into the metamodel; the source memory can be freed after this call returns.
Signature Variant A: Return t UMEMetamodelWriteI~. -:RegisterProperty( TypeCode~t Code, coast Char t * NameBuffer, coast Char t * DescriptionBuffer, TypeCode t Datatype, '16 WO 00/23$83 PCT/US99/24118 MetamodelFlags t Flags, coast char * DefaultBuffer, coast char *
ValidValuesBuffer, TypeCode t * UDPCode = NULL ) Variant B: Return t UMEMetamodelWriteI::RegisterObjectlmplementation( TypcCode t Code, coast LWTString & Name, coast LWTString & Description, TypeCode t Datatype, MetamodelFlags t Flags, UMEVaIucI * Default = NULL, coast LWTOrderedVectorT '<UMEVaIueI *> * ValidValues = NULL, TypeCode t * UDPCode = NULL ) Parameters Name Type Description The error code for the call, TypeCodes::Undefined to <retutn> R register a UDP.

Code I The typecode for the property.

Name I The internal name for the property.
with the internal name for the ff d b NameBuffer 1 er u A null-terminate l entries must have a name;
a null d e property. All metamo pointer here will prevent registration.

Description I The description of the property d buffer with the description of property.
i DescriptionBufferI nate A null-term If no description is available, pass a null pointer.

I The typecode for the data type used by this property.

Datatype I Metamodel flags (see description above).

Flags I The default value for the property.

Default 1 A buffer that the factory for the data type is capable of DefaultBuffer interpreting in order to determine the default value.

ValidValues I A list of the valid values for the property.
for the data type is capable of cto h f h ValidValuesBufferI ry e a at t A buffer t to determine the valid values.
d i O er n or interpreting ulated with typecode assigned to the UDP if Code is Po UDPCode p TypeCodes::Undefined.

Rea)sferProaerfyDatatype Description Registers a new data type for properties with the metamodel.
The metamodel does not assume responsibility for cleaning up factories-this allows these objects to be allocated off the heap or statically in the data segment. Instead, if a subscriber is provided, the metamodel will notify the subscriber when the entry for the property data typo is destroyed;
the subscriber can take appropriate cleanup action at that time. All other information is copied into the metamodel and can be freed when this method returns.
Signature Variant A: Return t UMEMetamodelWritet::RegisterPropertyDatatype( TypcCode t Code, coast Char t * NameBuffcr, coast Char t * DescriptionBuffer, UMEPropertyFactoryI *
Factory, MetamodelFlags~t Flags, UMESubscriberI * Subscriber = NULL ) Variant B: Return t UMEMetamodelWriteI::RegisterPropectyDatatype( TypeCode t Code, coast LWTString & Name, coast LWTString & Description, UMEPropertyFactoryl *
Factory, MetamodelFlags t Flags, UMESubscriberI * Subscriber = NULL ) Parameters Name Type Description R The error code for the call <return> I The typecode for the property data type Code I The internal name for the data type N~ I A null-terminated buffer with the internal name for the NameBuffer data type. All metamodel entries must have a name; a null pointer here will prevent registration.

Description I The description of the data type d buffer with the description of the data t i DescriptionBufferI e na A null-term type. if no description is available, pass a null pointer.

I The factory capable of constructing instances of the data Factory type I Metamodel flags (see description above) Flags I The subscriber to notify when this metamodel entry is Subscriber destroyed ReaisterPropertvUsaae Description Registers or unregisters the associations between a specified object and properties. The information will be copied into the metamodel, so all buffers cap: be freed once this method returns. Successive calls to this method with Add equal to True append information.
Signature Variant A: Return t UMEMetamodelWriteI -::RegisterPropertyUsage( TypeCode t Object, TypeCode_t' PropertiesBuffer, boot Add ) Variant B: Return t UMEMetamodelWriteI -::RegisterPropertyUsage( TypeCode t Object, const LWTOrderedVectorT~fypeCode 'ty & Properties, boot Add ) Parameters Name Type Description <retum> R The error code for the call Object I The object Properties I A list of the properties associated with the object type PropcrtiesBuffer I A list of the properties associated with the object type.
This buffer must be terminated with an entry having the value of TypeCodes::Undefined.
Add I True to add the association, False to remove the association.
RegisterPropertvUsaaes Description Allows bulk registration of object/pmperky associations. The information will be copied into the metamodel, so all buffers can be freed once this method returns. This method can only add associations.
The following set of grammar productions describes the format of the buffer.

Buffer EntryList Terminator _ EntryList En~' _ EntryList EntryList Entry _ Object PropertyList Terminator ~~y _ Property PropertyList _ ProperiyListPropertyList Property _ TerminatorTypeCodes:: Undefined _ Object any o6jece's rypecode _ Property any property's typecode _ Signature Retum_t UMEMetamodelWriteI::RegisterPropertyUsages( TypeCode t * Buffer Parameters Name Type Description <retutn> R The eaor code for the call Buffer I A buffer of typecodes ReuisterSianatureGenerator Description Registers a sign~ture generator into the model.
Signature Retum_t UMEMetamodelWriteI::RegisterSignatureGcncrator( const SignatureGeneratorId t 8 Id, UMESignatureGeneratorl * Generator, const LW'TString ~: Name ) Parameters Name Type Description <retutn> R The error coda for the call Id I The id for the signature generator Generator I The generator Name I The name of the generator for display purposes 1.1.9 UMEMetamodelUsel This is the interface that is used for metamodel operations other than reading and writing the metamodel.
CreateAccessor Description Creates an accessor appropriate for the property type. This allows construction of accessors in the absence of a property. This method employs the CreateAccessor method exposed by property factories.
Signature UMF.AccessorI -* UMEMetamodelUseI::CreateAccessor( TypeCode t Code ) '19 Parameters Nee Type Description ~;mm> R The accessor Code I The typecode of the property for which an accessor is needed Create0 ect Description Constructs a new object. If no owning object is specified, the object is made a child of the environment (if legal). If the object cannot be constructed, the output parameter will be set to NULL. No checks will be made on the initial content of Objtct.
Signature Result_t UMEMetamodelReadL:CreateObject( TypeCode t Code, UMEObjectl * Owner, UMEObjectl * &: Object, UMECbnstructionContext * Reserved = NULL ) Parameters Name Type Description R The error code for the call ~remm> I The typecode of the object Code I The owning object Owner O The object created, NULL
if not created Object Reserved for future use Reserved Getlnstances Description Retrieves the instances of the specified object type that exist in UMA. This list is not filtered nor a given persistence unit; that filtering can be accomplished quickly using UMEObjectl::Owner.
,:......._..._...;.:;:.T ,~. »: ...,"..., . . ;.,. , For performance reasons, the pointer returned by Variant A of this method might be a pointer to the actual data store used by the meGamodel. You must respect the const modifier and not modify the data in any way. If you want to alter the data, you must use Variant B.
Signature Variant A: Return_t UMEMetamodelUseL:GetInstances( TypcCode t Code, coast LWTOrderedVectorT~UMEObjectl *> * & Instances Variant B: Return t UMEMetamodelUseL:GetInstances( TypeCode t Code, LWTOrderedVectorT<UMEObjectI *> & Instances') ' UMEObjectl::Ownern is optimized for rctricving the pcrsistcncc unit. Sce the notes in the UMA Cookbook on this subject Parameters Nee 'Type Description <r~~m> R The error code for the call Code I The typecode for the object Instances O A list of the instances.
1.1.10 UMESemanticPackage!
Semantic packages are groups of logically-related semantics...e.g. the "Oracle"
semantics. There is a default package built into the metamodel to handle semantics required for the modeling engine's functions. Other packages may be constructed and registered for model elements as desired.
Jdentiffer Description Retrieves the identifier for the package.
Signature SemanticPackageld_t UMESemanticPackagel::Identifier( void ) const Parameters Name Type Description <retum> R The id of the package R alsterObiectSemantic Description Adds an object semantic into the package.
Signature Return t UMESemanticPackagel -::RegisterObjectSemantic( TypeCode t Code, UMEObjectSemanticl & Semantic, boot Internal ) Parameters Name Type Description R The error code of the call o I The object typecode for which the semantic applies Semantic I The semantic Internal I Is this semantic invoked internally (True) or via the API
(False) ReaisterPropertvSemantic Description Adds a property semantic into the package.

Signature Return_t UMESemanticPackageI::RegisterPropertySemantic( TypeCode t Object, TypeCode t Property, UMEObjectSemanticI & Semantic, bool lntemal ) Parameters Type Description <return> R The error code of the call Object I The object typecode for which the semantic applies Property I The property typecode for which the semantic applies Semantic I The semantic Internal I Is this semantic invoked internally (True) or via the API
(False) UMEObjectFactoryl Intet:face for all factory classes used to create instances of objects implementations. These implementations are then abased by the metamodel to the desired object type.
CIassSize Description Retrieves tht size of the object that will be allocated by CreateObject().
This is used by the UMEMetamodelReadI::GetltemSize{) method.
Signature size t UMEObjectFactoryL:ClassSize( TypeCode t Code ) Parameters Name Type Description <retum> R The size of the object Code I The typecode of the item CreateObiect Description Creates an instance of the object.
Signature UMEObjectI -* UMEObjectFactoryI::CreateObject( TypeCode t Code, UMEObjectI *
Owner, UMEFactoryContext * Reserved = NULL ) Parameters Nee Type Description R The newly created object 1 The typecode of the object to be created I The object that will own the item Reserved Reserved for future use pgstrovObfect Description Called by the metamodel to deallocate the memory for an object. This method, in combination with CreateObjectQ, allows the factory to implement custom memory allocation schemes, scarring, etc.
Signature void UMEObjectFactoryl::DestroyObject( UMEObjectl * Object ) Parameters Nee Type Description Item I The object to destroy 1.1.12 UMEPropertyFactoryl Interface for all factory classes used to create instances of property data types.
These data types are then aliased by the metamodel to create the desired properties.
ClassSlze Description Retrieves the size of the property that will be allocated by Createf ropertyQ.
This is used by the UMEMetamodelReadL:GetItemSizeQ method.
Signature size t UMEPropertyFactoryL:ClassSize( TypeCode t Code ) Parameters Name Type Description ~r~~~ R The size of the class Code I The typecode of the property CreateProaertv Description Creates an instance of the property.
Signature UMEPropertyl '* UMEPropertyFactoryI::CreateProperty( TypeCode t Code, UMEObjectl Owner, UMEFactoryContext * Reserved = MILL ) Parameters Nee Type Description <return> R The newly created property Code I The typecode of the property to be created O~~r I 'The object that will own the property Reserved Reserved for future use CreateAccesso_r Description Creates an accessor appropriate for the property.
Signature UMEAccessorl * UMEPropertyFactoryI::CreatcAccessor( TypeCode~t Code ) Parameters Name Type Description <return> R The accessor Code I The typecode of the property for which an accessor is needed DestrovAccessor Description Called by the metamodel to deallocate the memory for an accessor.
Signature void UMEPropertyFactoryI::DestroyAccessor( UMEAccessorI * Object ) Parameters Name Type Description Item I The accessor to destroy DestrovProperhc Description Called by the metamodel to deallocate the memory for a property. This method, in combination with CreateProperty(), allows the factory to implement custom memory allocation schemes, scarring, etc.
Signature void UMEPropertyFactoryI::DestroyProperty( UMEPropertyI * Object Parameters Name Type Description Item I The property to destroy 24i 1.1.13 UMEObjectl Interface for all objects within the UMA model.
FlndPronertv Description Locates the desired property on the object.
Signature UMEPropertyI * UMEObjectL:FindProperty( TypeCode t Type, Boolean Constructlfhull =
False, Boolean ConstructIfPreFetch ~ False ) Parameters Type Description Nee R The property, NULL if not found or constructed.

<retum> I The typecode of tire desired propertY
Type it will be is not found t ConstructIfNull, y I If set to True, and the proper constructed and returned.
erty is not found and is marked ro id th ConstructIfPreFetchp e p I If set to True, ar in the metamodel as a PreFetch property, it will be constructed and returned.

Ffacrs Description Retrieves the flags set upon the object. The flags are represented by bits ORed together.
NB: These flags should not be confused n~itlmtetnmodel flags on mr item n pe.
Signature ItemFlags t UMEObjectl::Flags( void ) const Parameters Name Type Description <rctum> R The bit flags on the item GetPronertv Description Retrieves the value of the specified property for the abject.
Signature Return t UMEObjectL:GetPcoperty( TypeCode t Type, UMEAccessorI & Accessor ) Parameters Nee Type Description <rctum> R The error code for the call ,~po I The typecodc of the desired property.
Accessor 1/O The accessor used to retrieve the value Description Retrieves the local id from the object Signature Id t UMEObjectL:Id( void ) const Parameters Name Type Description <retum> R Local id of the object lsEc~ual Description Determines ~f two objects are equal.
Signature Boolean UMEObjectI::IsEqual( UMEObjectl & Object, UMEObjectEqualityStrategyl ObjectStrategy ~ NULL, UMEPropertyEqualityStrategyI * PropertyStrategy = NULL
) Parameters Name Type Description <retum> R True if the objects test as equal Object I The other side of the comparison ObjcctStrategy i A strategy object that encapsulates the comparison algorithm for objects. If not supplied, the default algorithm is used.
PropertyStrategy I A strategy object that encapsulates the comparison algorithm for properties. If not supplied, the default algorithm is used.
~pertyEnual Description Determines if two properties are equal. By default, properties are equal if they belong to the same type of object, have the same typecode, and have the same value. Note that sorting is not performed on vector properties in the default strategy.
Signature Return't UMEObjectI::IsPropertyEqual ( UMEObjectl & Object, TypeCode_t Type, UMEPropcctyEqualityStrategyl * Strategy a NULL ) Parameters Name Type Description <return> R True if the properties test as equal Object I The object owning the other property Type 1 The typecode of the property PropertyStrategy I A strategy object that encapsulates the comparison algorithm for properties. If not supplied, the default algorithm is uscd.
IsTyne Description Determines if the object is of the specified type.
Signature boolean UMEObjectL:IsType ( TypeCode~t Type ) const Parameters Name Type Description <retum> R True if item is of the specified type Type I The typecode to test NuIIProperfy Description Deletes the property from the object.
Signature Return t UMEObjectI::NullProperty( TypeCode t Type, UMEAccessorI & Accessor ) Parameters Name Type Description <return> R The error code for the call Type I The typecode of the desired property.
Accessor I The accessor used to destroy the property Owner Descrlptlon Locates the owner of the desired type. This method can traverse multiple levels of ownership to locate the correct object.
Signature UMEObjectI _" UMEObject::IsType( TypeCode t Type = TypeCodes::Undefined) const Parameters Name Type Description <return> R The owning object of the specified type, NULL if none found.
Type I The typecode of the desired owner. If the default value is used, the immediate owner is returned.
SetPrQDert~c Description Sets the value of the specified property for the object.
Signature Return t UMEObjectL:SetProperty( TypeCode t Type, UMEAccessorl & Accessor ) Parameters Name Type Description <retunn> R The error code for the call Type I The typecode of the desired property.
Accessor I The accessor used to set the value Touch Description Allows semantic code to slag logically changed objects so they appear in the transaction log.
Touching an object marks it as modified even if no properties on the object changed. The touch can be removed by calling the method with the parameter set to False.
Signature void UMEObjectI::Touch ( Boolean On ) Parameters N~o Type Description On I True = modified, False a unmodified TouchProaertic Descriptioa Allows semantic code to flag logically changed properties so they appear in the transaction log.
Touching a property marks it as modified even if its value did not change. The touch can be removed by calling the method with the parameter set to False.
Signature void UMEObjectL:Touch ( Boolean On ) Parameters WO 00/23883 PC'T/US99/24118 Name Type Description ~~m> R The error code for the call Type I Typccode of the property Oa I True = modified, False ~ unmodified TxMcrr Description Retrieves the transaction manager monitoring the object.
Signature UMETxMgr * UMEObjectL:TxMgr ( void ) const Parameters Name Type Description <return> R The transaction manager, NULL if one is not active.
Tjrpe Description Retrieves the typecode of the object.
Signature TypeCode t UMEObjectL:Type ( void ) const Parameters Name Type Description <r~tum> R The typecode of the item VisitPropertv Description Locates the desired property and invokes the visitor upon it.
Signature Return t UMEObjectI::VisitProperty( TypeCode~t Type, UMEVisitorI &Visitor ) Parameters Name Type Description ~turn> R The error code for the call Type I The typecode of the desired property.
Visitor Il0 The visitor that will be employed 1.1.14 UMEPi'opertyl CreateAccessor Description Constructs an accessor for the property. This duplicates the functionality found in the property factory (which is exposed via UMEMetamodelUseI), and is provided for performance. For this reason, it is preferable that this not be implemented simply as a call to UMEMetamodelUseI::CreateAccessor.
Signature UMEAccessorI " UMEProperiyI::CreateAccessor( void ) Parameters Name Type Description <retum> R The accessor Flags Description Retrieves the flags set upon the item. The flags are represented by bits ORed together.
NB: Tlrese~!ags slrould not be confused ndth metnmodelJlrrgs on an item type.
Signature ItemFlags t UMEPropertyI::Flags( void ) const Parameters Name Type Description <retum> R The bit flags on the property IsTYJne Description Determines if the item is of the specified type.
Signature boolean UMEPropectyl::IsType ( TypeCode t Type ) const Parameters Name Type Description <return> R True if property is of the specified type Type I The typecode to test T~~pe Description Retrieves the typecode of the item.
Signature TypeCode t UMEPropertyI::Type ( void ) const Parameters Name Type Description <retum> R The typccode of the property 9.'l.95 UMEAccessorl Accessors control access to properties...setting values, getting values, and destroying properties. They ensure that the transaction manager and semantic mechanisms are managed correctly.
TJMEAccessorI defines the following action constants. Action constants determine what the accessor will attempt to do when used in a SetProperty call.
Constant Description l;Replace Replace the values in the property with the values in the accessor.

kAppend Append the values in the accessor to the values in the property. For scalar properties, this is the same as kReplace.

lcDelete Delete the values in the accessor from the values in the property.

kOverwriteFlags Change the flags on the property to match the flags in the accessor.

lcForceRefresh By default, an accessor will not attempt to modify the values in a property if the new values match the old values. If this action code is set, the modification will be forced.

Action Codes Description Retrieves the action codes currently set on the accessor.
Signature unsigned long UMEAccessorI:ActionCodes( void ) const Parameters Name Type Description <retum> R The current action codes Flaps Description Retrieves the property flags currently set on the accessor.
Signature ItemFlags t UMEAccessorI:Flags( void ) const Parameters Name Type Description <returtt> R The current flags GetPropertvValue Description Retrieves the value of the specified property. This method allows the user to bypass the property lookup inherent in UMEObjectI::GetProperty, if a reference to the property is available.
Signature Return tUMEAccessorI:GetPropertyValue( UMEObjectl' Object, UMEPropertyI' Property) Parameters Name Type Description <return> R The error code for the call Object 1 A reference to the object owning the property Property I A reference to the property NuIIPro>'erfvValue Description Logically deletes the specified property = This method allows the user to bypass the property lookup inherent in UMEObjecti::NullProperty, if a reference to the property is available.
Signature Return t UMEAccessorI:NullPropertyValue( UMEObjectI' Object, UMEPropertyI' Property) Parameters Name Type Description <retum> R The error code for the call Object I A reference to the object owning the property Property I A reference to the property SetActionCode Description Indicates what action the accessor is to take on a SetProperty call. The code can be a bitwise ORing of the action constants noted above.
Signature void UMEAccessorI:SetActionCode( unsigned long Code ) Parameters Name Type Description Flags I The flags desired on the property.
SetFlavs = Some properties do not actually delete upon destruction. Instead, a null flag is set.

Description Sets the flags desired on the property. 'this is used in conjunction with the kOverwriteFlags action code to set new flags on a property. Note that calling this method will have no effect on the property unless the kOverwriteFlags action code is set.
Signature void UMEAccessorI:SctFlags( ItemFlags_t Flags ) Parameters Name Type Description Flags I The flags desired on the property.
SefProaertvValue Description Sets the value of the specified'property. This method allows the user to bypass the property lookup inherent in UMEObjectl::SetProperty, if a reference to the property is available.
Signature Retum t UMEAccessorI:SetPropertyVafue( UMEObjectI " Object, UMEPropertyI ' Property) Parameters Name Type Description <return> R The error code for the call Object I A reference to the object owning the property Property I A reference to the property SetRaw Description Controls whether the accessor operates in raw or cooked mode. In raw mode, semantics are not fired. In cooked mode, semantics arc fired.
This method will do nothing if the accessor is active...i.e. in the midst of modifying a property.
Be very careful about using raw accessors. When you do so, you are oypassmg the mechanisms designed to maintain model integrity. The UMA Cookbook contains some examples of when you might want to do this. If in doubt, don't do it.
Signature boot UMEAccessorL:SetRaw( boot On ) Parameters Name Type Description <nt~> R The old state of the accessor: True equals raw, False equals cooked pn 1 The desired state of the accessor: True equals raw, False equals cooked 9.1.16 UMEScalarAccessorTl Extends: UMEAccessorI
Templated interface for scalar accessors.
SetValue Description Sets a value into the accessor.
Signature void UMEScalarAccessorTI~I'~::SetValue( const T & Value ) Parameters Name Type Description Value I The value to set in the accessor Value Description Retrieves the value in the accessor.
Signature T UMEScalarAccessorTI~::Value( void ) const Parameters Name Type Description <rcturn> R The value in the accessor 1.1.17 UMEVectorAccessorTl Extends: UMEAccessorI
Templated interface for vector accessors. Vector accessors are any that contain a set of scalar values (e.g.: arrays, lists, hash sets). They do not support sets of non-scalar values (e.g.: hash dictionary).
Vector accessors support an internal iterator that provides access to their values.

WO 00/Z3883 PCTlUS99/24118 Description Rcmove all values from the accessor.
Signature void UMEVectorAccessorTh.'I>::Clear( void ) Contains Description Determines if the specified value is in the accessor.
Signature bool UMEVectorAccessorTI~I'::Contains( const T & Value ) coast Parameters Name Type Description <return> R True if the accessor contains the value Count Description Determines the number of items in the accessor.
Signature unsigned long UMEVectorAccessorTI<h::Count( void ) coast Parameters Name Type Description <return> R The number of items in the accessor Get~lextValue Description Advances the internal itcrator and retrieves the next value.
Signature bool UMEVectorAccessorTl<1'?::GetNextValue( T & Value Parameters Name Type Description <return> R True if there is another value, Fatse if no more Value O The value Resetlterator Description Resets the internal iterator.
Signature void UMEVectorAccessorTI~'I'~::ResetIterator( void ) SetValue Description Add a value or values to the accessor.
Signature Variant A: void UMEVectorAccessorTI~::SetValue( const T & Value ) Variant B: void UMEVectorAccessarTI<i>::SetValue( const LWTOrderedVectorTfi ~:
Vatues ) Parameters Name Type Description Value I A single value to append~to the accessor Values I A set of values to append to the accessor 1.1.18 UMEObjectSemanticl Defines the interface for all object semantics. Object semantic events are identified by a series of bit flags.
UMEObjectSemanticI defines the following event ids:
Can Constant Abort Description kPostCreation N Fired immediately after the object is created by the user kPreDesttuction Y Fired immediately before the object is to be destroyed kPreTypeCodeC:hange Y Fired immediately before subtype migration kPostTyptCodet~tange Y Fired immediately after subtype migration kManagt:Cache N Fired immediately after the object is created by a load from persistent store or by the transaction manager. .
Fire Description Invokes the semantic.
Signature Return t UMEObjectSernanticL:Fire( SemanticEvcnt t Event, UMEObjectI & Object, UMEObjectSemanticContext' Reserved = NULL ) Parameters Name Type Description <r~~> It The error code for the call Event I 'The semantic event that is being triggered Object I The object being affected Reserved Reserved for future use Interests Descrlptlon Retrieves the semantic events that the semantic handles. This is used for performance enhancement. This method is called only once, upon registration of the semantic with the metamodel. The events handled by the semantic cannot be altered at runtime.
Signature SemanticEvent t UMEObjectSemantic::Interests( void ) const Parameters Name Type Description <return> R The flags indicating the semantic events handled 1.1.19 UMEPropertySemanticl Defines the interface for all property semantics.
Property semantic events are identified by a series of bit flags.
UMEPropertySemanticI defines the following event ids:
Can Constant Abort Description IcPreF.dit Y Fired just before a property's value is changed kPostF.dit Y Fired just after a property's value is changed kPreDestcuetion Y Fired just before a property is destroyed kPreFetch N For properties flagged as prefetch type in the metamodel and that have the kPreFctch instance ttag turned on, fired just before the value of the property is read.

kPostClip N Property was just clipped kPreOwnerDestructionN The owning object is about to be destroyed Fire Description Invokes the semantic.
Signature Return t UMEPropertySemanticL:Fire( SemanticEvent t Event, UMEObjectI &
Object, UMEPropertyI & Property, UMEPropertySemanticContext' Reserved = NULL ) Parameters N~~ Type Description <return> R The error code for the call Event I The semantic event that is being triggered Object I The object being affected Property I The property being affected Reserved Reserved for future use Interests Description Retrieves the semantic events that the semantic handles. This is used for performance enhancement. This method is called only once, upon registration of the semantic with the metamodel. The events handled by the semantic cannot be altered at runtime.
Signature SemanticEvent t UMEPropertySemantic::Interests( void ) const Parameters Name Type Description <return> R The flags indicating the semantic events handled 1.1.20 UMETxCommandl Transaction commands are used to specify a set of actions that are to take place at the end of the current transaction.
As an example, the semantic mechanism does not allow a property that is the subject of a semantic firing to be destroyed in the midst of the event. To do so would remove the property from memory before all semantics had an opportunity to complete. Attempts to destroy a property in this circumstance result in a destruction command being queued with the transaction manager. After all semantics have fired, the property will be destroyed.
Description Executes the command.

Signature boot UMETxCommandI::Do( void ) Parameters Name Type Description <return> R True if the command executed successfully.
9.1.21 UMETxMg~l Interface used for managing transactions.
Ado~tCommand Description Puts a command into the transaction manager's queue for execution at the end of the transaction.
The command must be allocated on the heap and responsibility for its destruction passes to the transaction manager.
Signature Result t UMETxMgrI::AdoptCommand( UMETxCommandl' Command ) Parameters Name Type Description <return> R The error code for the call Command I Command object to be enqueued Beam Description Starts a transaction.
Signature Variant A: Result t UMETxMgrL:Begin ( UMETxId1 * & Id, boolean Notify ~ false, UMETxDataI * Data, boot AutoDestruct = false ) Variant B: Result t UMETxMgrI::Begin( UMETxIdI * & Id, UMESubscriberI *
Subscn'ber ) Parameters Name Type Description <retuin> ji; The error code for the call Id O Receives the transaction ld assigned to the new transaction Notify I indicates if subscribers to the transaction manager should be notified when this transaction closes.

Data I Programmer-detincd data to store with the transaction.
AutoDesttuct I Indicates if this transaction will be undoable after it is closed Subscriber I A non-null value causes a one-time subscription to the transaction manager.
CurrentTxLd Description Retrieves the id of the current transaction.
Signature const UMETxIdI '' UMETxMgrI::CurrentTxId ( void ) Parameters Name Type Description <retum> R ld of the current transaction End Description Ends a transaction and causes a commit of the events within it.
Signature Result t UMETxMgrI::End( UMETxIdI ~ Id ) Parameters Name Type Description <return> R The error code for the call Id I Identifies the transaction to be ended.
Fail Description Fails a transaction and causes a rollback of the events within it.
Signature Result t UMETxMgrI::Fail( UMETxIdI ~ Id ) Parameters Name Type Description <retttrn> R The error code for the call Id I Identifies the transaction to be failed.
GetTxData Description Retrieves the transaction data attached to the specified transaction.

Signature Return t UMETxMgrI::GetTxData( UMETxIdI * Id, UMETxData * & Data ) Parameters Name Type Description <return> R The error code for the call Id I The transaction id Data O Receives the transaction data GetOuterTxLlst Description Retrieves a list of the outermost (user) transactions.
Signature Return~t UMETxMgrI::GetOuterTxList( LWTOrderedVectorT<UMETxidI *> &
Transactions) const Parameters Name Type Description <retum> R The error code for the call Transactions O The list of outer transactions GetTxld Description Retrieves the transaction id for a named transaction.
Signature Return t UMETxMgrI::GetTxId( const LWTString ~: Name, UMETxidl * ~ Id ) const Parameters Name Type Description <retum> R The error code for the call LI~n~ I The name of the transaction Id O The id of the transaction GetTxName Description Retrieves the name of a transaction.
Signature Return t UMETxMgrL:GetTxName( UMETxIdt * Id, LWTString & Namc ) const Parameters 4'1 Name Type Description <ro~> R The error code for the call Id I The transaction id N~u O The name of the transaction lsLogg~i~_a Description Determines if the transaction manager is currently logging.
Signature boot UMETxMgrI::IsLogging( void ) const Parameters Name Type Description <retunn> R True if logging IsOk Description Determines if the transaction manager is :n a good state.
Signature boot UMETxMgrL:IsOk( void ) const Parameters Name Type Description <retum> R True if Ok IsTxOpen Description Determines if a transaction is currently open.
Signature boot UMETxMgrI::IsTxOpen( void ) const Parameters Name Typc Description <return> R True if a transaction is open.
NextTxld Description Retrieves the id of the next transaction.
Signature UMETxIdI "' UMETxMgrI::NextTxId( void ) Parameters Name Type Description <ru~> R Id of the next transaction Pause Description Causes the transaction manager to suspend logging.
Signature Result t UMETxMgrL:Pause( void ) Parameters Name Type Description <return> R The error code of the Call PrevlousTxld Description Retrieves the id of the previous transaction.
Signature UMETxIdt * UMETxMgrI::PreviousTxId( void ) Parameters Name Type Description <return> R Id of the previous transaction Resume Description Causes the transaction manager to resume logging.
Signature Result t UMETxMgrI::Resume( void ) Parameters Name Type Description <return> R The error code of the call SetTxName Descrtptton Specifies a user-readable name for a transaction.
Signature Return t UMETxMgrI::SetTxName( UMETxIdI * Id, const LWTString & Name ) Parameters Name Type Description <return> R The en:or code for the call Id I The id of the transaction Name I The name to set on the transaction Description Causes the transaction manager to redo to the specified transaction.
Signature Rtsult t UMETxMgrL:Redo( UMETxIdI * Id ) Parameters Name Type Description <return> R The error code of the call Id I Identifies the transaction to be redone Reset Description Causes the transaction manager flush all transactions and return to its initial state.
Signature Result t UMETxMgrI::Reset( void ) Parameters Name Type Description <return> R The error code of the call Undo Description Causes the transaction manager to undo to the specified transaction.
Signature Result t UMETxMgrI::Undo( UMETxIdI * Id ) Parameters Name Type Description <return> R The error code of the call Id I Identifies the transaction to be undone 1.1.22 UMEVisitorl Vlslt Description Invokes the visitor to operate on the specified item.
Signature Variant A: Retutn_t UMEVisitorI::Visit( UMEObjectl * Object ) Variant B: Return t UMEVisitorI::Visit( UMEPropertyI * Property ) Parameters Name Type Description <return> R The error code for the call Object ~ I The object to visit Property I The property to visit 1.1.23 UMEPropertylteratorl Used to iterate across the properties owned by an object.
As with all UMA iterators, it uses a "move then read" metaphor-you must increment before reading the next value.
Filter and sorting are supported for this iterator.
Count Description Returns the number of properties that will be iterated. Note, if a filter is used, the iterator will have to traverse the property list to determine the actual count.
Signature long UMEUMEPropertyIteratorL:Count{ void ) const Parameters Name Type Description <n~> R The number of items that will be iterated Reset Description Re-initializes the iterator.
Signature void UMEUMEPropertyIteratorL:Reset( boot Recalculate ) Parameters Name Type Description Recalculate I If True, the sorting and filtering (if any) will be re-performed. If False, the old filtering and sorting remain in effect.
SetFllter Description Sets the filter to be used on the iterator. Changing the filter once iteration has begun will cause a reset to be performed on the iterator.
Signature void UMEUMEPropertyIteratorI::SetFilter( UMEFiIterTl<UMEPropertyI *> * Filter ) Parameters Name Type Description Filter I The filter to be used while iterating SefSorter Description Sets the sorter to be used on the iterator. Changing the sorter once iteration has begun will cause a reset to be performed on the iterator.
Signature void UMEUMEPropertyIteratorI::SetSorter( UMESorterTl<UMEProperryl *> * Sorter ) Parameters Name Type Description Sorter I The Sorter to be used while iterating Value Description Retrieves the value at the current iterator position. If the iterator is before the beginning of the container, the results are undefined.
Signature UMEPropertyI' UMEUMEPropertyIteratorI::Value ( void ) const Parameters Name Type Description <retum> R The currant value of the iterator operator++

Description Increments the iterator.
Signature boot UMEUMEPropertyIteratorI::operator++( void ) Parameters Name Type Description <retum> R True if the iteration succeeded, False if there are no more entries.
1.1.24 UMEFiiterTl This is the interface for a templated filter used by the various iterators in the UMA
modules.
Test Description Tests the item to see if it should be included in the iteration.
Signature boot UMEFiIterTI<I'r::Test( T & Item ) Parameters Name Type Description <return> R True if the item should be included, False if not Item I The item to be tested 1.1.25 UMESorterTl This is the interface for a templated sorter used by the various iterators in the UMA modules.
sart Description Sorts the buffer of items into the desired order.
Signature boot UMESorterTi~::Sort( T' Buffer, long Count ) Parameters Name Type Description Buffer I A buffer of items to be sorted ~~t 1 The number of items in the buffer 1.1.26 UMESignatureGeneratorl Signature generators are conceptually similar to visitors, they encapsulate an algorithm for operating on an object. In their case, they extract a signature for the object. A signature is a string that uniquely identifies the object in the model.
Multiple signature generators can be registered with the metamodel to provide different algorithms for matching objects.
Signature generators must advertise the level of the values they generate. The level of a signature indicates the scope of its uniqueness. The levels are indicated by the constants in the following table. For each level, an example is provided indicating a signature for a database table.
Constant Description kUniversal The signature is unique across time and space. An example would be a string representation of a GU1D.

CBSBDCBI-93C1-llcf 8F20-00805F2CD064 kInstallationThe signature is unique across time, but its uniqueness is limited to a particular repository of models. An example would be a string representation of a ModelMart 3.0 id.

kSession The signature is unique across models in memory, but is not unique once the current session ends. An example would be a string representation of an UMA local id.

kPersistenceUnitThe signature is unique across a persistence unit in memory. An example would be a string concatenating the typecode, project name, model name, owner name, and table name.

43.Projectl.OracleModel.tdeffler.Customer kWorkspace The signature is unique across a workspace in memory. An example would be a string concatenating typecode, owner name, and table name.
GetSlgmature 43tdefRerCustomer Description Constructs a signature for the object. If the object type is not supported, an empty string will be returned.

e.~ature void UMESignatureGeneratorI::GetSignature( UMEObjectl' Object, LWTString &
Signature ) coast Parameters Name Typc Description Object I The object for which a signature is generated Signature O The signature Id Description Retrieves the id.
Signature SignatureGeneratorId_t UMESignatureGeneratorl::Id( void ) coast Parameters Name Type Description <return> R The id SlgrnatureLevel Description Returns a constant indicating the type of signature generated.
Signature long UMESignatureGeneratorI::SignatureLevel( void ) coast 'arameters tame Type Description ~rn> R The signature level

Claims (16)

what is claimed is:

1. An apparatus for building a modeling tool, comprising:
a meta model including a semantic registry and a meta data manager;
an object/property interface;
an object/property factory registry coupled to the meta model and the object/property interface; and an object/property model coupled to the object/property interface.

2. The apparatus according to claim 1, further comprising a transaction manager coupled to the object/property interface for undoing an action that places the object/property model in an invalid state.

3. The apparatus according to claim 1, wherein the semantic registry of the meta model includes at least a predefined set of semantics.

4. The apparatus according to claim 1, wherein the semantic registry of the meta model includes at least one set of semantics provided by a developer.

5. The apparatus according to claim 1, wherein the object/property factory registry of the meta model includes at least one object factory for creating an instance of an object and one property factory for creating an instance of a property.

6. The apparatus according to claim 1, wherein the object/property model includes a predefined set of at least one of a plurality of objects and a plurality of properties.

7. The apparatus according to claim 1, wherein the object/property model includes instances of objects and properties based on an external definition of the meta model.

8. The apparatus according to claim 2, further comprising a log file coupled to the transaction manager object/property interface.

9. The apparatus according to claim 1, wherein the object/property interface limits access to the object/property model.

10. A method for building a modeling tool, comprising:
constructing an object/property model by defining a first set of classes;
constructing a meta model by defining a second set of classes;
associating a type code with the first and second set of classes;
providing a predefined set of semantics to the meta model;
identifying a plurality of discrete events, wherein at least one semantic of the set of semantics is invoked at each occurrence of the plurality of discrete events; and providing an object/property interface for limiting access to the object/property model.

11. The method according to claim 10, further comprising:

providing a transaction manager for undoing an action that places the object/property model in an invalid state.

12. The method according to claim 10, wherein the object/property model includes a predefined set of at least one of a plurality of objects and a plurality of properties.

13. The method according to claim 10, wherein the object/property model includes instances of objects and properties based on an external definition of the meta model provided by the developer.

14. The method according to claim 10, wherein the meta model includes at least one set of semantics provided by the developer.

15. An apparatus for building a modeling tool, comprising:
a first model including a registry and a data manager;
an interface;
a factory registry coupled to the first model and the interface; and a second model coupled to the interface;
wherein the registry includes semantics.

16. A method for building a modeling tool, comprising:
constructing a first model by defining a first set of classes;
constructing a second model by defining a second set of classes;

associating a type code with the first and second set of classes;
providing a predefined.set of semantics to the first model;
identifying a plurality of discrete events, wherein at least one semantic of the set of semantics is invoked at each occurrence of the plurality of discrete events; and providing an interface for limiting access to the first model.