Note : Les descriptions sont présentées dans la langue officielle dans laquelle elles ont été soumises.
CA 02255054 1998-11-30
METHOD AND MECHANISM FOR A TASK ORIENTED DATA MODEL
A portion of the disclosure of this patent document contains
material which is subject to copyright protection. The copyright
owner has no objection to the facsimile reproduction by anyone of
the patent document or the patent disclosure, as it appears in the
Patent Office patent files or records, but otherwise reserves all
copyrights whatsoever.
REFERENCE TO RELATED APPLICATIONS
This application is related to the co-pending application
entitled Method and Mechanism for a Task Oriented XML Data Model
filed in the name of the common assignee.
FIELD OF THE INVENTION
The present invention relates to object oriented
programming systems, and more particularly to a task oriented
structure for a data model and method for validating the data
model.
BACKGROUND OF THE INVENTION
Traditionally in the computer programming art, program
code and data have been kept separate. For example, in the well-
known C programming language, units of program code are called
functions, and units of data are called structures. In C the
functions and structures are not formally connected, that is, a
function can operate on more than one type of data structure, and
more than one function can operate on the same structure.
CA998-041 1
CA 02255054 1998-11-30
Object-oriented programming, in contrast, deals with
objects, in which program code and data are merged into a single
indivisible entity or "object". An object is an instance of an
implementation and an interface and models a real-world entity.
The object is implemented as a computational entity that
encapsulates state and operations and responds to requests. The
data and methods are implemented internally in the object. A
business object for example is an object containing business
methods (i.e. logic) and state that is intended for use within
business applications.
Objects are built using an application program commonly
referred to as an object builder tool. The object builder tool is
a program which is used to define the business objects and generate
the necessary definition and implementation files in IDL (Interface
Definition Language) , C++ and/or Java, as will be understood by
those skilled in the programming arts.
Object builders utilize a data model which provides a
template of the data structure for the objects. Object-oriented
data models can be adapted to a wide range of different models by
changing the definitions of meta-data, such as the objects and the
task trees. Meta-data, as will be understood by those skilled in
the art, comprises the self-descriptive information that can
describe both services and information. With meta-data new
services can be added to a system and discovered at run-time.
The object builder in the Component Brokerr"' toolkit from
IBM utilizes a proprietary data model known as the Common Data
Model (CDM) which comprises a binary file. In the object builder
CA998-041 2
CA 02255054 1998-11-30
tool, objects are designed by performing sets of user-defined
operations in the form of task trees.
Frequently, users will want to load an application
program with data by means other than the user interface for the
application. For example, in a spreadsheet program, a user may
wish to load a subset of data extracted from a database. To be
able to perform such a data load or import, an alternate user
interface or an import capability will typically be required in
order to translate the extracted subset of data into a form
suitable for the spreadsheet program. The alternate user interface
or import capability is needed to check the data for constraints
that must be applied in order not to break the application.
Typically, this involves an expensive piece of development work
done by the provider of the application program. As a result, such
a load capability is not usually provided.
BRIEF SUMMARY OF THE INVENTION
What is provided according to the present invention is a
data structure which allows the data import facility in an
application program to be simplified.
According to one aspect of the invention, the data
structure comprises a task oriented data structure. The task
oriented data structure is specified according to a hierarchical
data model for the application. By providing the data in a task
oriented structure, the data provides scripting for the import
facility and allows the data to be validated according to the
hierarchical data model when it is loaded into the application.
CA998-041 3
CA 02255054 1998-11-30
According to another aspect of the invention, the data
model is expressed in an exportable and importable document in
meta-data language such as XML, i.e. Extensible Markup Language.
The data model expressed as an XML document is arranged in a task
oriented structure which mirrors the user interface of the
application (e. g. an object builder). The data model is specified
according to a meta data model which takes the form of one or more
Document Type Definitions (DTD's) in XML. The meta data model,
i . a . DTD, specifies the set of required and optional data elements ,
and their attributes, for the data model expressed as an XML data
document. According to the invention, the data model specified by
the DTD is arranged in a hierarchical structure which represents
the task flow or sequence that is followed by a user to enter the
data.
To export a data model, the data model is expressed as a
structured XML document file which mirrors the exact order in which
the object data model was created by the user. Because the tasks
are expressed in terms of containment relationships in the XML
document as defined by the DTD, the importation, i.e. reading, of
the XML document serves to extract the data model in the same
sequence the data was entered. It will be appreciated that this
approach eliminates the need for tags and other indicators of
location as is the case for conventional data export/import files.
To import a data model, i.e. an XML document file, the
export/import utility includes an XML parser. The XML parser
parses the XML document and builds a "document tree" which is then
returned to the data import/export utility. Because the XML
document file, i.e. the data model, is arranged as a task oriented
CA998-041 4
CA 02255054 1998-11-30
structure, the document file provides scripting for translating
each data element contained in the data model. In addition, the
XML document file, i.e. the data model, is validated when the
import utility loads the document file by comparing the data model
to a meta data model specified in the form of the DTD.
In accordance with an aspect of the invention, there is
provided a task oriented data structure embodied in a program
storage device for an object oriented application program, the
object oriented application program having a user interface
comprising a plurality of items, said items defining a sequence of
tasks for creating one or more objects, said data structure
comprising: (a) a data model suitable for storage on a storage
media; (b) said data model including a plurality of data elements;
(c) each of said data elements corresponding to one of the tasks in
said sequence of tasks; and (d) said data elements being arranged
according to a meta data model, wherein said meta data model
mirrors the sequence of tasks defined in the user interface. Said
meta data model may include means for validating each of said data
elements and the arrangement of said data elements . Said data model
may also be expressed in an Extensible Markup Language or XML, and
said data elements being arranged according to containment
constructs specified in said meta data model. And, said means for
validating may comprise a Document Type Definition specified in
XML.
There is also provided, in an application program for creating
objects, the application program having a user interface comprising
a plurality of items, said items defining a sequence of tasks for
creating the objects, and said application program including an
CA998-041 5
CA 02255054 1998-11-30
import utility for importing document files, a import utility
comprising: (a) means for inputting a document file expressed in a
meta data programming language, and wherein said document file
comprises a plurality of data elements, each of said data elements
corresponding to one of the tasks in said sequence of tasks, and
said data elements being arranged according to a meta data model,
wherein said meta data model mirrors the sequence of tasks defined
in the user interface; (b) parser means for parsing said document
file according to said meta data programming language, and said
parser means including means for creating a document tree, said
document tree comprising a plurality of nodes, wherein each of said
nodes corresponds to an item in the user interface; and (c) means
for updating the object according to the nodes contained in said
document tree. Said meta data model may also include means for
validating each of the nodes in said document tree. Said document
file may further comprise a text file expressed in Extensible
Markup Language or XML, and said data elements being arranged
according to containment constructs specified in said meta data
model. Said means for validating may also comprise a Document Type
Definition specified in XML. And, said document file may include
scripting means for translating each of said data elements.
In accordance with another aspect of the invention, there is
provided a computer program product for an application program for
creating objects, the application program having a user interface
comprising a plurality of items, said items defining a sequence of
tasks for creating the objects, and said application program
including an import utility for importing document files, said
computer program product comprising a program storage device; means
recorded on said program storage device for instructing a computer
CA998-041 6
CA 02255054 1998-11-30
to perform the steps of, (a) inputting a document file, wherein
said document file is expressed according to a meta data
programming language, said document file comprising a plurality of
data elements, each of said data elements corresponding to one of
the tasks in said sequence of tasks, and said data elements being
arranged according to a meta data model, wherein said meta data
model mirrors the sequence of tasks defined in the user interface;
(b) parsing said document file according to said meta data
programming language; (c) creating a document tree from said parsed
document file, said document tree comprising a plurality of nodes,
wherein each of said nodes corresponds to an item in the user
interface; and (d) updating the object according to the nodes
contained in said document tree. Said computer program product
further including validating means for use by said parsing means
for validating each of the nodes in said document tree. Said meta
data language may comprise Extensible Markup Language or XML, and
said data elements being arranged according to containment
constructs specified in said meta data model. And, said means for
validating may comprise a Document Type Definition specified in
XML.
There is also provided a computer system for creating objects
in an application program, the application program having a user
interface comprising a plurality of items, said items defining a
sequence of tasks for creating the objects, and said application
program including an import utility for importing document files,
said computer system comprising: (a) means for inputting a document
file, wherein said document file is expressed according to a meta
data programming language, said document file comprising a
plurality of data elements, each of said data elements
CA998-041 7
CA 02255054 1998-11-30
corresponding to one of the tasks in said sequence of tasks, and
said data elements being arranged according to a meta data model,
wherein said meta data model mirrors the sequence of tasks defined
in the user interface; (b) a parser for parsing said document file
according to said meta data programming language; (c) means for
creating a document tree from said parsed document file, said
document tree comprising a plurality of nodes, wherein each of said
nodes corresponds to an item in the user interface; and (d) means
for updating the object according to the nodes contained in said
document tree. The computer system may also include validating
means for use by said parser for validating each of the nodes in
said document tree. Said meta data language may comprise Extensible
claim Markup Language or XML, and said data elements being arranged
according to containment constructs specified in said meta data
model. Said validating means may comprise a Document Type
Definition specified in XML. And, said data model may include
scripting means for translating each of the data elements in said
document file.
CA998-041 8
CA 02255054 1998-11-30
BRIEF DESCRIPTION OF THE DRAWINGS
Reference will now be made to the accompanying drawings
which show, by way of example, a preferred embodiment of the
present invention, and in which:
Fig. 1 is a diagrammatic representation of the main
window of an object builder of the type suitable for a task
oriented data model according to the present invention; and
Fig. 2 is a flow chart showing the processing steps
performed by a data import utility to load a task oriented data
model according to the present invention.
DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
The present invention comprises a task oriented data
structure for use with a data import and export utility in an
application program.
According to one embodiment of the invention, the task
oriented data model is implemented using the open standard language
XML (Extensible Markup Language). The data model is expressed as
a structured XML document which is specified according to a meta
data model contained in a Document Type Definition or DTD. The
meta data model specified in the Document Type Definition is also
arranged as a hierarchical structure which mirrors the user
interface task flow sequence in the application program. The XML
data document is compatible with the export and import utility in
development tools (e. g. object builder tool). In the following
CA998-041 9
CA 02255054 1998-11-30
description, the task oriented structure is described in the
context of an object builder tool which is in the "toolkit" for the
IBM Component Broker?"" software package.
Reference is first made to Fig. 1, which shows in
diagrammatic form the object builder tool 10 in the Component
Broker toolkit. The object builder tool 10 is an application
program which provides an integrated development environment for
software developers. As shown in Fig. 1, the object builder 10
comprises a main window 20 having four panes denoted by 21, 22, 23,
and 24 respectively. The first pane 21 on the left side of the
window 20 provides the main view which is a task tree view. The
main view in the first pane 21 is also the context for the content
displayed in the three other panes 22, 23, and 24.
As shown in Fig. 1, the main view pane 21 comprises a
"Framework Interfaces" item 110, a "User-Defined Business Objects"
item 120, a "User-Defined Compositions" item 130, a "User-Defined
Data Objects" item 140, a "DBA-Defined Schemas" item 150, a "User-
Defined PA Schemas" item 160, a "Non-IDL Type Objects" item 170, a
"Build Configuration" item 180, an "Application Configuration" item
190, a "Container Definition" item 200, a "Default Homes" item 210,
and a "FlowMark" item 220. The content of the other three panes
22, 23 and 24 in the window 10 depends on the selected item or
element in the main view pane 21.
CA998-041 10
CA 02255054 1998-11-30
It will be appreciated that the object builder 10
utilizes a task tree structure. As shown in Fig. 1, the "User-
Defined Business Objects" item 120 has a user interface which is
organized as a task tree structure . The task oriented structure of
the user interface forces a user to follow a specified sequence in
order to create a business object, i.e. an object containing
business methods (logic) and data (state) that is intended for use
within business applications. As will now be described, the data
model and the underlying meta data model according to the present
invention comprise task oriented structures which mirror the user
interface. The data model includes all the persistent meta-data
which is used by the object builder tool 10.
Referring to Fig. 1, and specifically the main view pane
21, the task tree structure for the "User-Defined Business Objects"
item 120 comprises a file item or element 121, a module element
122, an interface element 123, a key helper element 124, a copy
helper element 125, a business object implementation element 126,
and a data object element 127. The "User-Defined Data Objects"
item 140 is also organized in a task tree structure and comprises
a file element 141, a module element 142, and a interface element
142. Similar task tree structures are provided for the "DBA-
Defined Schemas" item 150, the "Non-IDL Types Objects" item 170,
the "Build Configuration" item 180, the "Application Configuration"
item 190, and the "Container Definition" item 200.
CA998-041 11
CA 02255054 1998-11-30
According to the task tree structure for the "User-
Defined Business Objects" item 120, a business object is created by
the following sequence of steps: (1) create file; (2) create
module; (3) create interface; (4) create key helper; (5) create
copy helper; and (6) create implementation.
The first step performed by a user involves creating a
file. The object builder 10 generates the file as an IDL
(Interface Definition File). As will be understood by one skilled
in the art, IDL is a contractual, neutral and declarative language
that specifies an object's boundaries and its interfaces, e.g. the
aspects of the object that are accessible to the public. IDL
provides operating system and programming language independent
interfaces to all services and components that reside on a bus as
defined according to the CORBA (Common Object Request Broker
Architecture) standard. The second step is optional and allows a
user to define a module which comprises a grouping of interfaces.
The third step performed by the user involves defining the public
interface for the user-defined business object. The fourth step
involves creating a key helper which comprises an object which
provides a copy of the "identity" of the business object. The
fifth step involves creating an object which duplicates everything
about the business object, not just its identity. The sixth step
comprises implementing the specific behaviour, i.e. methods, for
the business object.
According to the present invention, the data model
comprises a task oriented structure which preserves the sequence of
steps followed by a user during the creation of the object. The
CA998-041 12
CA 02255054 1998-11-30
data model for an object, i.e. instance of data, is expressed by
the object builder tool in the form of an XML document which
mirrors the exact order in which the object was created by the
user. The underlying meta data model also mirrors the task
oriented or hierarchical structure of the user interface . The data
model thereby provides a data structure from the which the user
interface of the object builder tool can be inferred. Since the
user interface is implicit in the organization of the data model,
the data model can be imported by another tool by simply following
or scripting the data model.
According to another aspect of the invention, the task
oriented data model is expressed as a document file using the meta-
data language XML (i.e. Extensible Markup Language) and the meta
data model takes the form of Document Type Definition or DTD also
specified in XML. A meta-data language is self-descriptive of both
services and information and is preferred because the data model
can be generically validated by reading or importing the data
model. The meta data model, i.e. Document Type Definition or DTD,
is used for validating the correctness of the data model which is
expressed as an XML document.
According to this aspect of the present invention, the
meta data model for the "User-Defined Business Objects" item 120
takes the form of a Document Type Definition which is specified as
shown below.
CA998-041 13
CA 02255054 1998-11-30
<?xml encoding="US-ASCII"?>
<!ELEMENT UserDefinedBusinessObject (BusinessObjectUnit)*>
<!ELEMENT UserDefinedDataObject (DOFile)*>
<!ELEMENT BusinessObjectUnit (BOFile ~ CompositeFile)*>
<!ELEMENT DBADefinedSchemas (SchemaGroup)*>
<!ELEMENT UserDefinedPAOs (Schema)*>
<!__ ************************** Bo File **************************** __>
<!ELEMENT BOFile (Comments) IncludeFile~ Module ~ BOArtifact
Constant ~ Enumeration ~ Exception ~ Structure ~ Typedef I Union I Uuid)*>
<!ATTLIST BOFile Name CDATA #IMPLIED>
<!ELEMENT Comments (#PCDATA)*>
<!ELEMENT IncludeFile (#PCDATA)*>
<!ELEMENT Uuid (#PCDATA)*>
<!__********************* Composite File ************************** __>
<!ELEMENT CompositeFile (Comment s IncludeFile~ Module ~ BOArtifact
2 0 Constant ~ Enumeration ( Exception I Structure I Typedef ~ Union I Uuid)*>
<!ATTLIST CompositeFile Name CDATA #IMPLIED>
<!__ ************************** Module **************************** __>
<!ELEMENT Module (#PCDATA ( BOArtifact ~ DOArtifact ~ Comments ~ Constant
2 5 Enumeration ~ Exception ~ Structure ~ Typedef ~ Union ~ Uuid)*>
<!ATTLIST Module Name CDATA #IMPLIED>
CA998-041 14
CA 02255054 1998-11-30
<!__ ***************************** DO File *************************** __>
<!ELEMENT DOFile (Comments ~ IncludeFile ~ Module ~ DOArtifact
Constant ~ Enumeration ~ Exception ~ Structure ~ Typedef ~ Union ~ Uuid)*>
<!ATTLIST DOFile
Name CDATA #IMPLIED>
<!__ *************************** BOArtlfaCt ************************ __>
<!ELEMENT BOArtifact (Interface KeyArtifact ~ CopyArtifact ~
BOImplementation)*>
<!ELEMENT Interface (#PCDATA ~ IsQueryable ~ IsWLM I Comments
InterfaceInheritance ~ Attribute ~ Method ( Constant ~ Enumeration ~ Exception
Structure ~ Typedef ( Union ~ Uuid ~ObjectRelationship ~ Compositelnfo)*>
<!ATTLIST Interface
Name CDATA #IMPLIED>
<!ELEMENT IsQueryable (#PCDATA)*>
<!ELEMENT IsWLM (#PCDATA)*>
<!ELEMENT InterfaceInheritance (#PCDATA)*>
<!__ *************************** COmpOSlteInfO *********************** __>
<!ELEMENT CompositeInfo (CompositeRules ~ InterfaceReference)*>
2 0 <!ATTLIST CompositeInfo
CompositeToolMoniker CDATA #IMPLIED>
<!__*************************** CompositeRules *********************** __>
<!ELEMENT CompositeRules (#PCDATA)*>
<!__*********************** InterfaceReference ********************* __>
<!ELEMENT InterfaceReference EMPTY>
CA998-041 15
CA 02255054 1998-11-30
<!ATTLIST InterfaceReference
Referenced CDATA #IMPLIED
InstanceInterface CDATA #IMPLIED
InstanceName CDATA #IMPLIED
InstanceKind CDATA #IMPLIED>
<!__************************ DataReference *************************** __>
<!ELEMENT DataReference (Prereq I DataStore ~ Chain I Select)*>
<!ATTLIST DataReference
1O Type CDATA #IMPLIED
ReferencedCategory CDATA #IMPLIED
ReferencedInterface CDATA #IMPLIED
ReferencedName CDATA #IMPLIED
ReferencedKind CDATA #IMPLIED
InstanceInterface CDATA #IMPLIED
InstanceName CDATA #IMPLIED
InstanceKind CDATA #IMPLIED>
<!__ ****************************** Prereq *************************** __>
2 0 <!ELEMENT Prereq (Prereq ~ DataStore ~ Chain ~ Select)*>
<!ATTLIST Prereq
ReferencedParameterName CDATA #IMPLIED
ReferencedParameterKind CDATA #IMPLIED
TargetInterface CDATA #IMPLIED
2 5 OperationName CDATA #IMPLIED
OperationKind CDATA #IMPLIED
CA998-041 16
CA 02255054 1998-11-30
ParameterName CDATA #IMPLIED
ParameterKind CDATA #IMPLIED
Helper CDATA #IMPLIED
ReferencedCategory CDATA #IMPLIED
ReferencedInterface CDATA #IMPLIED
ReferencedName CDATA #IMPLIED
ReferencedKind CDATA #IMPLIED
InstanceInterface CDATA #IMPLIED
InstanceName CDATA #IMPLIED
InstanceKind CDATA #IMPLIED>
<!__**************************** DataStOre *************************** __>
<!ELEMENT DataStore (#PCDATA)*>
<!ATTLIST DataStore
ReferencedCategory CDATA #IMPLIED
ReferencedInterface CDATA #IMPLIED
ReferencedName CDATA #IMPLIED
ReferencedKind CDATA #IMPLIED
InstanceInterface CDATA #IMPLIED
2 0 InstanceName CDATA #IMPLIED
InstanceKind CDATA #IMPLIED>
<!__ ****************************** Chain *************************** __>
<!ELEMENT Chain EMPTY>
<!__ ****************************** Select *************************** __>
CA998-041 17
CA 02255054 1998-11-30
<!ELEMENT Select (NullAttribute)*>
<!__************************* NullAttrlbute *********************** __>
<!ELEMENT NullAttribute (Prereq ~ DataStore ~ Chain ~ Select)*>
<!ATTLIST NullAttribute
AttributeInterface CDATA #IMPLIED
AttributeName CDATA #IMPLIED
AttributeKind CDATA #IMPLIED
Negated CDATA #IMPLIED
ReferencedCategory CDATA #IMPLIED
ReferencedInterface CDATA #IMPLIED
ReferencedName CDATA #IMPLIED
ReferencedKind CDATA #IMPLIED
InstanceInterface CDATA #IMPLIED
InstanceName CDATA #IMPLIED
InstanceKind CDATA #IMPLIED>
<!__************************** DelegateTOGroup *********************** __>
<!ELEMENT DelegateToGroup (#PCDATA)*>
<!__************************* KeyAttrMapGYOUp ********************** __>
<!ELEMENT KeyAttrMapGroup (KeyAttrMapInfo)*>
<!__************************* KeyAttrMapIrifO ********************** __>
2 5 <!ELEMENT KeyAttrMapInfo (KeyAttrReference)*>
<!ATTLIST KeyAttrMapInfo
CA998-041 18
CA 02255054 1998-11-30
Interface CDATA #IMPLIED
AttributeName CDATA #IMPLIED
AttributeKind CDATA #IMPLIED>
<!__************************* KeyAttrReference ********************** __>
<!ELEMENT KeyAttrReference (KeyAttributeReference
InstanceAttributeReference)*>
<!--*********************** KeyAttributeReference ******************** -->
<!ELEMENT KeyAttributeReference EMPTY>
<!ATTLIST KeyAttributeReference
Interface CDATA #IMPLIED
AttributeName CDATA #IMPLIED
AttributeKind CDATA #IMPLIED>
<!--****************** InstanceAttributeReference ******************** -->
<!ELEMENT InstanceAttributeReference EMPTY>
<!ATTLIST InstanceAttributeReference
Interface CDATA #IMPLIED
2 0 AttributeName CDATA #IMPLIED
AttributeKirid CDATA #IMPLIED>
<!__ *********************** LocationGroup *************************** __>
<!ELEMENT LocationGroup (LocationByKey)*>
<!__*********************** LOCatIOriBYKey *************************** __>
CA998-041 19
CA 02255054 1998-11-30
<!ELEMENT LocationByKey (InterfaceReference)*>
<!ATTLIST LocationByKey
Group CDATA #IMPLIED
FindObject CDATA #IMPLIED
CreateObject CDATA #IMPLIED
RemoveObject CDATA #IMPLIED
CreateFromCopy CDATA #IMPLIED
HomeName CDATA #IMPLIED
FactoryFinderName CDATA #IMPLIED
HomeParameter CDATA #IMPLIED>
<!__********************** Abject Relationship ******************** __>
<!ELEMENT ObjectRelationship (Uuid ~ ObjectType
ReferenceCollectionImplementation ~ ReferenceResolvedByForeignKey ~
HomeToQuery
Attribute ~ Method)*>
<!ATTLIST ObjectRelationship Name CDATA #IMPLIED>
<!ELEMENT ObjectType (#PCDATA)*>
<!ELEMENT ReferenceCollectionImplementation (#PCDATA)*>
<!ELEMENT ReferenceResolvedByForeignKey (#PCDATA)*>
<!__ **************************** COriStruct ************************** __>
<!ELEMENT Constant (Type ~ Initializer I Size I Uuid)*>
<!ATTLIST Constant
Name CDATA #IMPLIED>
<!ELEMENT Enumeration (Member ~ Uuid)*>
<!ATTLIST Enumeration
CA998-041 20
CA 02255054 1998-11-30
Name CDATA #IMPLIED>
<!ELEMENT Exception (Member I Uuid)*>
<!ATTLIST Exception Name CDATA #IMPLIED>
<!ELEMENT Member (Type I Size ~ TypeSpecification I SequenceSize ~ ArraySize
CaseLabel ~ Uuid)*>
<!ATTLIST Member Name CDATA #IMPLIED>
<!ELEMENT TypeSpecification (#PCDATA)*>
<!ELEMENT SequenceSize (#PCDATA)*>
<!ELEMENT ArraySize (#PCDATA)*>
<!ELEMENT CaseLabel (#PCDATA)*>
<!ELEMENT Structure (Member I Uuid)*>
<!ATTLIST Structure Name CDATA #IMPLIED>
<!ELEMENT Typedef (Type ~ Size ~ TypeSpecification ~ SequenceSize ~ ArraySize
Uuid) *>
<!ATTLIST Typedef Name CDATA #IMPLIED>
<!ELEMENT Union (SwitchSpecifier I Member I Uuid)*>
<!ATTLIST Union Name CDATA #IMPLIED>
<!ELEMENT SwitchSpecifier (#PCDATA)*>
<!__ **************************** Attribute ************************** __>
<!ELEMENT Attribute (Type) Initializer~ Size) Implementation) Read-only)
Overridable~ (StringBehaviour?) ~ GetterMethodBodyForPlatform
SetterMethodBodyForPlatform ~ GetterImplementationType ~
SetterImplementationType
ParentInterface ~ DOAttributeName I Uuid ~ DataReference I DelegateToGroupl
UsedInImplementation ~ StaticData
GetterBodiesKeepAllPlatformsInSyncCpp
GetterBodiesKeepAllPlatformsInSyncJava
CA998-041 21
CA 02255054 1998-11-30
SetterBodiesKeepAllPlatformsInSyncCpp
SetterBodiesKeepAllPlatformsInSyncJava)*>
<!ATTLIST Attribute
Name CDATA #IMPLIED>
<!ELEMENT Type (#PCDATA)>
<!ELEMENT Initializer (#PCDATA)*>
<!ELEMENT Size (#PCDATA)*>
<!ELEMENT Implementation (#PCDATA)>
<!ELEMENT Read-only (#PCDATA)>
<!ELEMENT Overridable (#PCDATA)>
<!ELEMENT StringBehaviour (#PCDATA)>
<!ELEMENT GetterImplementationType (#PCDATA)*>
<!ELEMENT SetterImplementationType (#PCDATA)*>
<!ELEMENT DOAttributeName (#PCDATA)*>
<!ELEMENT ParentInterface (#PCDATA)*>
<!ELEMENT UsedInImplementation (#PCDATA)*>
<!ELEMENT StaticData (#PCDATA)*>
<!ELEMENT GetterBodiesKeepAllPlatformsInSyncCpp (#PCDATA)*>
<!ELEMENT GetterBodiesKeepAllPlatformsInSyncJava (#PCDATA)*>
2 0 <!ELEMENT SetterBodiesKeepAllPlatformsInSyncCpp (#PCDATA)*>
<!ELEMENT SetterBodiesKeepAllPlatformsInSyncJava (#PCDATA)*>
<!ELEMENT GetterMethodBodyForPlatform (Language)*>
<!ATTLIST GetterMethodBodyForPlatform Name CDATA #IMPLIED>
<!ELEMENT SetterMethodBodyForPlatform (Language)*>
2 5 <!ATTLIST SetterMethodBodyForPlatform Name CDATA #IMPLIED>
<!--ELEMENT ImplementationLanguage ANY-->
CA998-041 22
CA 02255054 1998-11-30
<!ELEMENT Language (UseToolDef, UseFile, UseTDE,Filename?, ToolDef?,
UserDef?,((OOSQLSourceType?, OOSQLUserDef?) ~ (ESQLSourceType?,
ESQLUserDef?))?)>
<!ATTLIST Language
Name CDATA #IMPLIED>
<!ELEMENT UseToolDef (#PCDATA)>
<!ELEMENT UseFile (#PCDATA)>
<!ELEMENT UseTDE (#PCDATA)>
<!ELEMENT Filename (#PCDATA)*>
<!ELEMENT ToolDef (#PCDATA)*>
<!ELEMENT UserDef (#PCDATA)*>
<!ELEMENT OOSQLSourceType (#PCDATA)*>
<!ELEMENT OOSQLUserDef (#PCDATA)*>
<!ELEMENT ESQLSourceType (#PCDATA)*>
<!ELEMENT ESQLUserDef (#PCDATA)*>
~!-_**************************** Method ************************** -->
<!-- Preserve spaces and newline -->
<!ATTLIST Filename xml:space (default~preserve) "preserve">
<!ATTLIST ToolDef xml:space (default~preserve) "preserve">
<!ATTLIST UserDef xml:space (default~preserve) "preserve">
<!ATTLIST Comments xml:space (default~preserve) "preserve">
<!ATTLIST OOSQLUserDef xml:space (default~preserve) "preserve">
<!ATTLIST ESQLUserDef xml:space (default~preserve) "preserve">
<!-- Preserve spaces and newline -->
2 5 <!ELEMENT Method (ReturnType ~ Size ~ Implementations
MethodBodyForPlatform
One-way ~ Overridable ~ ConstMethod ( IsFrameworkMethod ~ ExceptionRaises
Context ~ Parameter ~ Uuid I ParentInterface I DataReference ~ DelegateToGroup
MethodType ~ UsedInlmplementation ~ StaticMethod ~ PushDownMethod
CA998-041 23
CA 02255054 1998-11-30
MappedMethod ~ PlatformSet I MethodBodiesKeepAllPlatformsInSyncCpp
MethodBodiesKeepAllPlatformsInSyncJava)*>
<!ATTLIST Method
Name CDATA #IMPLIED>
<!ELEMENT ReturnType (#PCDATA)>
<!ELEMENT ConstMethod (#PCDATA)>
<!ELEMENT PushDOwnMethod (#PCDATA)*>
<!ELEMENT MappedMethod (#PCDATA)*>
<!ELEMENT MethodBodyForPlatform (Language)*>
<!ATTLIST MethodBodyForPlatform Name CDATA #IMPLIED>
<!ELEMENT ImplementationType (#PCDATA)*>
<!ELEMENT Designpattern (#PCDATA)*>
<!ELEMENT UseMacro (#PCDATA)>
<!ELEMENT One-way (#PCDATA)>
<!ELEMENT IsFrameworkMethod (#PCDATA)>
<!ELEMENT ExceptionRaises (#PCDATA)*>
<!ELEMENT Context (#PCDATA)*>
<!ELEMENT StaticMethod (#PCDATA)*>
<!ELEMENT PlatformSet (#PCDATA)>
2 0 <!ELEMENT MethodBodiesKeepAllPlatformsInSyncCpp (#PCDATA)*>
<!ELEMENT MethodBodiesKeepAllPlatformsInSyncJava (#PCDATA)*>
<!ELEMENT Parameter (ParameterType ~ Size I DirectionalAttr ~ Uuid )*>
<!ATTLIST Parameter
Name CDATA #IMPLIED>
2 5 <!ELEMENT ParameterType (#PCDATA)*>
<!ELEMENT DirectionalAttr (#PCDATA)*>
CA998-041 24
CA 02255054 1998-11-30
<!ELEMENT MethodType (#PCDATA)*>
<!__********************** DOArtifaCt ***************************** __>
<!ELEMENT DOArtifact (DOInterface~ Comments)*>
<!__************************* Key ********************************* __>
<!ELEMENT KeyArtifact (#PCDATA~ File ~ Module ~ Interface ( Attribute ~ Method
InterfaceInheritance ~ Uuid ~ Prologue ~ CppPrologue ~ JavaPrologue ~ Epilogue
CppEpilogue ~ JavaEpilogue ~ KeyAttrMapGroup)*>
<!ELEMENT File (#PCDATA I Uuid I IncludeFile I Comments )*>
<!ATTLIST File Name CDATA #IMPLIED>
<!__************************** Copy ********************************* __>
<!ELEMENT CopyArtifact (#PCDATA ~ File ~ Module ~ Interface ~ Attribute ~
Method
~ InterfaceInheritance ~ Uuid ~ Prologue ~ CppPrologue ~ JavaPrologue~
Epilogue
CppEpilogue ~ JavaEpilogue)*>
<!__************************** BO Implementation ******************** __>
<!ELEMENT BOImplementation (#PCDATA~ File I Module I Interface I Pattern
2 0 LazyEvaluation ~ DataObjectInterface ~ SessionableBO ~
ImplementationLanguage
UserData ~ ImplementationInheritance ( Attribute ~ Method ~ Prologue
CppPrologue ~ JavaPrologue ~ Epilogue ~ CppEpilogue ~ JavaEpilogue ~ Key ~
Copy
Handle ~ DOInterface ~ MO ~ Uuid ~ LocationGroup ~ ObjectRelationship)*>
<!ELEMENT Pattern (#PCDATA)>
2 5 <!ELEMENT LazyEvaluation (#PCDATA)>
<!ELEMENT DataObjectInterface (#PCDATA)>
<!ELEMENT SessionableBO (#PCDATA)>
<!ELEMENT ImplementationLanguage (#PCDATA)*>
<!ELEMENT UserData (#PCDATA)*>
3 0 <!ELEMENT ImplementationInheritance (#PCDATA)>
CA998-041 25
CA 02255054 1998-11-30
<!ELEMENT Prologue (#PCDATA)*>
<!ELEMENT CppPrologue (#PCDATA)*>
<!ELEMENT JavaPrologue (#PCDATA)*>
<!ELEMENT Epilogue (#PCDATA)*>
<!ELEMENT CppEpilogue (#PCDATA)*>
<!ELEMENT JavaEpilogue (#PCDATA)*>
<!ELEMENT Key (#PCDATA)*>
<!ELEMENT Handle (#PCDATA)*>
<!-- Preserve spaces and newline -->
<!ATTLIST Prologue xml:space (default~preserve) "preserve~'>
<!ATTLIST CppPrologue xml:space (default~preserve) "preserve">
<!ATTLIST JavaPrologue xml:space (default~preserve) "preserve">
<!ATTLIST Epilogue xml:space (default~preserve) "preserve">
<!ATTLIST CppEpilogue xml:space (default~preserve) "preserve">
<!ATTLIST JavaEpilogue xml:space (default~preserve) "preserve">
<!__************************* DO Stuff ***************************** __,
<!ELEMENT DOInterface (File ~ Module ~ Interface I Comments
2 0 InterfaceInheritance ~ DOImplementation ~ Attribute ~ Method ~ Constant
Enumeration ~ Exception ~ Structure ~ Typedef ~ Union ~ Uuid)*>
<!ATTLIST DOInterface
Name CDATA #IMPLIED>
<!__*************************** DO Implementation ******************* __>
<!ELEMENT DOImplementation (#PCDATA ~ File I Module ~ Interface I Environment
PersistentBehaviour ~ DataAccessPattern ~ PointerHandle ~ Key ~ Copy
CA998-041 26
CA 02255054 1998-11-30
ImplementationInheritance ~ Attribute ~ Method ~ Prologue ~ CppPrologue
JavaPrologue ~ Epilogue ~ CppEpilogue ~ JavaEpilogue ~ PO ~ POMapping ~
Uuid)*>
<!ELEMENT Environment (#PCDATA)*>
<!ELEMENT PersistentBehaviour (#PCDATA)*>
<!ELEMENT DataAccessPattern (#PCDATA)*>
<!ELEMENT PointerHandle (#PCDATA)*>
<!ELEMENT Copy (#PCDATA)*>
<!__************************** PO Stuff *************************** __>
<!ELEMENT PO (Quid?, ShortName?, ModuleName?, JavaPackage?, JavaPath?,
PAOService?, POAccessType, Prologue?, CppPrologue?, JavaPrologue?, Epilogue?,
CppEpilogue?, JavaEpilogue?, BindFileName, Comments?, POAttribute*, POMethod*,
Schema?)>
<!ATTLIST PO
Name CDATA #IMPLIED>
<!ELEMENT POAccessType (#PCDATA)>
<!ELEMENT BindFileName (#PCDATA)*>
<!ELEMENT POAttribute (Uuid?, Type, Size, ColumnName, KeySequenceNumber?,
Key?,
Getter?, Setter?, GetterBodiesKeepAllPlatformsInSyncCpp?,
SetterBodiesKeepAllPlatformsInSyncCpp?, GetterMethodBodyForPlatform*,
SetterMethodBodyForPlatform*)>
<!ATTLIST POAttribute Name CDATA #IMPLIED>
<!ELEMENT KeySequenceNum (#PCDATA)*>
<!ELEMENT KeySequenceNumber (#PCDATA)*>
2 5 <!ELEMENT POMethod (Uuid?, IsFrameworkMethod, MethodFunction?,
Implementation,
ReturnType, POParameter*, PlatformSet?,
MethodBodiesKeepAllPlatformsInSyncCpp?,
MethodBodyForPlatform*)>
<!ATTLIST POMethod Name CDATA #IMPLIED>
<!ELEMENT POParameter (Type, Size?, ParmAccessType?)>
3 0 <!ATTLIST POParameter Name CDATA #IMPLIED>
CA998-041 27
CA 02255054 1998-11-30
<!ELEMENT ParmAccessType (#PCDATA)>
<!__*********************** DOImpl->PO Mapplrigs ********************* __>
<!ELEMENT POMapping (AttributeMapping*, MethodMapping*)>
<!ELEMENT AttributeMapping (DataObjectAttribute, PatternType?,
PrimitiveMapping?,((POAttributelmplementation+, MappingHelper?) ~ (KeyMapping
StructMapping)*)?)>
<!ELEMENT DataObjectAttribute (#PCDATA)>
<!ELEMENT PatternType (#PCDATA)>
<!ELEMENT PrimitiveMapping (POAttributeImplementation+, MappingHelper?)>
<!ELEMENT POAttributeImplementation (POInstance, POInstanceAttribute)>
<!ELEMENT POInstance (#PCDATA)>
<!ELEMENT POInstanceAttribute (#PCDATA)>
<!ELEMENT MappingHelper (MappingHelperClass, MappingHelperToTarget,
MappingHelperToSource)*>
<!ELEMENT MappingHelperClass (#PCDATA)*>
<!ELEMENT MappingHelperToTarget (#PCDATA)*>
<!ELEMENT MappingHelperToSource (#PCDATA)*>
<!ELEMENT KeyMapping (KeyFullName, HomeToQuery, (KeyAttributeMapping)*)>
2 0 <!ELEMENT KeyFullName (#PCDATA)>
<!ELEMENT HomeToQuery (#PCDATA)*>
<!ELEMENT KeyAttributeMapping (KeyAttribute, (POAttributeImplementation)*,
MappingHelper?)>
<!ELEMENT KeyAttribute (#PCDATA)>
2 5 <!ELEMENT StructMapping (StructFullName, (StructAttributeMapping)*)>
<!ELEMENT StructFullName (#PCDATA)>
<!ELEMENT StructAttributeMapping (StructAttribute, PrimitiveMapping?,
(KeyMapping
StructMapping)*)>
CA998-041 28
CA 02255054 1998-11-30
<!ELEMENT StructAttribute (#PCDATA)>
<!ELEMENT MethodMapping (DataObjectMethod, AlwaysCompletes,
(POMethodImplementation)*)>
<!ELEMENT POMethodImplementation (POInstance, POInstanceMethod)>
<!ELEMENT DataObjectMethod (#PCDATA)*>
<!ELEMENT AlwaysCompletes (#PCDATA)*>
<!ELEMENT POInstanceMethod (#PCDATA)>
<!__************************** Schema Stuff ************************* __>
<!ELEMENT Schema (((DatabaseName, UserName?, SchemaName,
ContainedBySchemaGroup,
DatabaseType?, SchemaType, PKConstraint?, PKConstraintComment?, Comments?,
SQLFilename, Column*,((ForeignKey*) I(ViewSelect?, ViewFrom?, ViewWhere?,
ViewOrderby?, ViewGroupby?, ViewHaving?, IsUserWrittenClause?, ViewSchema+,
ViewColumnMapping?))) ~(SchemaName, ShortName, ModuleName, SchemaType,
JavaPackage, JavaPath, JavaClassName, PAOService, Property*, SchemaMethod*)),
PO* ) >
<!ATTLIST Schema
Name CDATA #IMPLIED>
<!ELEMENT ContainedBySchemaGroup (#PCDATA)*>
2 0 <!ELEMENT DatabaseName (#PCDATA)>
<!ELEMENT UserName (#PCDATA)*>
<!ELEMENT SchemaName (#PCDATA)>
<!ELEMENT ShortName (#PCDATA)>
<!ELEMENT ModuleName (#PCDATA)>
2 5 <!ELEMENT SchemaType (#PCDATA)>
<!ELEMENT PKConstraint (#PCDATA)*>
<!ELEMENT PKConstraintComment (#PCDATA)*>
<!ELEMENT SQLFilename (#PCDATA)*>
<!ELEMENT JavaPackage (#PCDATA)>
CA998-041 29
CA 02255054 1998-11-30
<!ELEMENT JavaPath (#PCDATA)>
<!ELEMENT JavaClassName (#PCDATA)>
<!ELEMENT PAOService (#PCDATA)>
<!ELEMENT SchemaMethod (Uuid?, IsFrameworkMethod, MethodFunction?,
Implementation, ReturnType, SchemaParameter*)>
<!ATTLIST SchemaMethod Name CDATA #IMPLIED>
<!ELEMENT MethodFunction (#PCDATA)*>
<!ELEMENT SchemaParameter (Type, Size?)>
<!ATTLIST SchemaParameter Name CDATA #IMPLIED>
<!ELEMENT Column (ColumnName, ColumnType, NotNull, KeySequenceNumber,
ColumnSequenceNumber, Length, Scale, ForBitData, Comments)>
<!ATTLIST Column
Name CDATA #IMPLIED>
<!ELEMENT ColumnName (#PCDATA)>
<!ELEMENT ColumnType (#PCDATA)>
<!ELEMENT NotNull (#PCDATA)>
<!ELEMENT ColumnSequenceNumber (#PCDATA)*>
<!ELEMENT Length (#PCDATA)>
<!ELEMENT Scale (#PCDATA)>
2 0 <!ELEMENT ForBitData (#PCDATA)>
<!ELEMENT Property (TypeString, TypeQualifier, Size, Key?, Getter?, Setter?,
Uuid? ) >
<!ATTLIST Property
Name CDATA #IMPLIED>
<!ELEMENT TypeString (#PCDATA)>
<!ELEMENT TypeQualifier (#PCDATA)>
<!ELEMENT Getter (#PCDATA)>
CA998-041 30
CA 02255054 1998-11-30
<!ELEMENT Setter (#PCDATA)>
<!ELEMENT ForeignKey (IsUnnamed, ForeignKeyName?, TargetSchema,
Comments, FKMapping*)>
<!ATTLIST ForeignKey Name CDATA #IMPLIED>
<!ELEMENT ForeignKeyName (#PCDATA)*>
<!ELEMENT IsUnnamed (#PCDATA)>
<!ELEMENT TargetSchema (DatabaseName, UserName?, SchemaName,
ContainedBySchemaGroup)>
<!ELEMENT FKMapping (OwningAttribute, TargetAttribute)>
<!ELEMENT OwningAttribute (#PCDATA)>
<!ELEMENT TargetAttribute (#PCDATA)>
<!ELEMENT ViewSelect (#PCDATA)*>
<!ELEMENT ViewFrom (#PCDATA)*>
<!ELEMENT ViewWhere (#PCDATA)*>
<!ELEMENT ViewOrderby (#PCDATA)*>
<!ELEMENT ViewGroupby (#PCDATA)*>
<!ELEMENT ViewHaving (#PCDATA)*>
<!ELEMENT IsUserWrittenClause (#PCDATA)*>
<!ELEMENT
ViewSchema
(DatabaseName,
UserName?,
SchemaName,
2 ContainedBySchemaGroup)>
0
<!ELEMENT ViewColumnMapping (ViewColumn*)>
<!ELEMENT ViewColumn (TargetSchema, TargetColumn)>
<!ATTLIST ViewColumn Name CDATA #IMPLIED>
<!ELEMENT TargetColumn (#PCDATA)*>
<!__************************ SchemaGroup Stuff ********************* __>
CA998-041 31
CA 02255054 1998-11-30
<!ELEMENT SchemaGroup (DatabaseName?, DatabaseType?, DDLFilename?,
EditGeneratedFile?, Schema*)>
<!ATTLIST SchemaGroup
Name CDATA #IMPLIED>
<!ELEMENT DatabaseType (#PCDATA)*>
<!ELEMENT DDLFilename (#PCDATA)*>
<!ELEMENT EditGeneratedFile (#PCDATA)*>
<!__***************************** MO Stuff ************************** __>
<!ELEMENT MO (File ~ Module ~ Interface ~ ImplementationInheritance
MOApplicationAdaptor ~ Uuid)*>
<!ELEMENT MOApplicationAdaptor (#PCDATA)*>
<!__ HBO ? __>
CA998-041 32
CA 02255054 1998-11-30
As shown above the meta data model in the form of the Document
Type Definition (DTD) specifies the set of required and optional
elements, and their attributes, for the XML documents which contain
the data content of the objects. In addition, the DTD specifies
the names of the tags and the relationships among elements in the
XML document. It will also be appreciated that the task tree
elements for the "User-Defined Business Objects" 120 are expressed
using containment relationships in the Document Type Definition
shown above. For example, the file element 121 is defined as
<!ELEMENT BOFile(Comments~....~Uuid)*>, and the module element 122
is defined as <!ELEMENT Module (#PCDATA~....Uuid)*>. Similarly, in
the DTD the "attributes" of the object are defined as <!ELEMENT
Attribute (Type ~Initializerl....)*>, and the "methods" of the
object are defined as <!ELEMENT Method (ReturnType~.....)*>. The
specific syntax in the meta data model as specified in the above
DTD will be within the understanding of those familiar with XML.
According to the present invention, the data model
comprises a task oriented structure which preserves the sequence of
steps followed by a user during the creation of the object. Thus,
the data model for the object, i.e. instance of data, is stored
according to the meta data model in the exact order created by the
user, and the data model thereby provides a data structure from
which the user interface of the object builder tool can be
inferred. Since the user interface is implicit in the organization
of the data model, the data model can be imported by another tool
by simply following or scripting the data structure.
CA998-041 33
CA 02255054 1998-11-30
In order to take advantage of the task oriented structure
expressed in XML, a data import/export utility in accordance with
the present invention is implemented to include an XML parser. In
known manner, the XML parser is a validating parser which uses the
Document Type Definition to validate each element in the XML
document, i.e. the data model. In the present context, the
validating XML parser parses the XML data document and builds a
"document tree" which is then returned to the data import/export
utility.
To export a data file, the data model is expressed as a
structured XML document file which as described above mirrors the
exact order in which the object was created by the user. Because
the tasks are expressed in terms of containment relationships in
the XML document as defined by the DTD (i.e. the meta data model),
the importation, i.e. reading, of the XML document serves to
extract the data model in the same sequence the data model was
created. It will be appreciated that this approach eliminates the
need for tags and other indicators of location as is the case for
conventional data import/export files. The validation of the data
model occurs implicitly as the XML document is read by the data
import/export utility.
Reference is made to Fig. 2 which shows in flow chart
form the principle steps performed by a data import/export utility
according to the present invention. In this example, a task
oriented data model according to the present invention is to be
imported by the object builder tool 10 (described above with
reference to Fig. 1). The first step as shown in Fig. 2 involves
CA998-041 34
CA 02255054 1998-11-30
making a call to the data import utility (step 201) . Next, the
data import utility retrieves the XML document from memory (step
202) and passes the document to the validating XML parser (step
203 ) . The XML parser then parses the XML document and builds a
document tree for the XML document (step 204). Preferably, the XML
parser is a validating parser, which means that each element
appearing in the XML document is validated against the meta data
model specified in the Document Type Definition. Upon completion
of the parsing and validation of the XML document, the document
tree is returned to the data import utility (step 205). The next
step performed by the data import utility involves adding or
updating the object according to the data model for each element
contained in the document tree (step 206). After the object has
been added or updated based on the contents of the XML document
file, control returns to the object builder (i.e. application
program).
The invention may be implemented as a computer program product
comprising a program storage device and means recorded on said
program storage device for instructing a computer to perform the
steps of the invention and as a data structure embodied in a
program storage device. Such a program storage device may include
diskettes, optical discs, tapes, CD-ROMS, hard drives, memory
including ROM or RAM, computer tapes or other storage media capable
of storing a computer program.
The invention may also be implemented in a computer system. In
a preferred embodiment, a system is provided comprising a computer
program operating on a data processing system, with the computer
CA998-041 35
CA 02255054 1998-11-30
program embodying the method of the invention and producing an
output of the method on a display or output device. Data processing
systems include computers, computer networks, embedded systems and
other systems capable of executing a computer program. A computer
includes a processor and a memory device and optionally, a storage
device, a video display and/or an input device. Computers may
equally be in stand-alone form (such as the traditional desktop
personal computer) or integrated into another apparatus (such as a
cellular telephone).
while this invention has been described in relation to
preferred embodiments, it will be understood by those skilled in
the art that changes in the details of processes and structures may
be made without departing from the spirit and scope of this
invention. Many modifications and variations are possible in light
of the above teaching. Thus, it should be understood that the above
described embodiments have been provided by way of example rather
than as a limitation and that the specification and drawing are,
accordingly, to be regarded in an illustrative rather than a
restrictive sense.
CA998-041 36
