(12) United States Patent
`Saulpaugh et al.
`
`US006298354B1
`US 6,298,354 B1
`Oct. 2, 2001
`
`(10) Patent N0.:
`(45) Date of Patent:
`
`(54) MECHANISM AND PROCESS TO
`TRANSFORM A GRAMMAR-DERIVED
`INTERMEDIATE FORM TO AN
`OBJECT-ORIENTED CONFIGURATION
`DATABASE
`
`(75) Inventors: Thomas E. Saulpaugh, San Jose;
`Gregory L. Slaughter, Palo Alto;
`Bernard A. Traversat, San Francisco,
`all of CA (US)
`
`(73) Assignee: Sun Microsystems, Inc., Palo Alto, CA
`(Us)
`
`( * ) Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21) Appl. No.: 09/253,839
`(22) Filed:
`Feb. 19, 1999
`
`(51) Int. Cl.7 .................................................... .. G06F 17/30
`(52) US. Cl. ........................................... .. 707/103; 707/100
`(58) Field of Search .................................... .. 707/103, 100
`
`(56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`5,551,029 * 8/1996 Jagadish et al. ................... .. 707/103
`5,694,598 * 12/1997 Durand ............ ..
`707/103
`
`5,758,154 * 5/1998 Qureshi . . . . . . . . .
`
`. . . . . . .. 713/1
`
`6,182,082 * 1/2001 Tanaka et al. ..................... .. 707/103
`
`FOREIGN PATENT DOCUMENTS
`
`0 631 229
`
`12/1994 (EP).
`
`OTHER PUBLICATIONS
`
`Majka, “Getting Acquainted With NetInfo,” Nextstep In
`Focus, Summer 1993, vol. 3, Issue 3, copyright NeXT
`Computer, Inc. 1993.
`
`* cited by examiner
`
`Primary Examiner—Jack Choules
`Assistant Examiner—Cheryl Lewis
`(74) Attorney, Agent, or Firm—Conley, Rose & Tayon, PC;
`B. Noel Kivlin
`
`(57)
`
`ABSTRACT
`
`Amethod and system for transforming an intermediate form
`into an object-oriented database. The intermediate form is
`derived from a grammatical form of an object-oriented
`database through the process of compilation. The grammati
`cal form is an expression of an object-oriented database in
`a textual form according to a grammar. The intermediate
`form comprises an array of intelligent entry objects that
`encapsulate data With methods for manipulating that data.
`The intermediate form comprises entries as in the object
`oriented database but lacks the infrastructure of the database.
`The intermediate form can be used to populate the object
`oriented database With entries. Population takes place
`through a public API for accessing the object-oriented
`database; in other Words, through an interface Which
`declares methods for navigating the database and adding
`entries to the database. The object-oriented database is an
`obj ect-oriented con?guration database Which stores con?gu
`ration parameters pertaining to the softWare and hardWare of
`a computer system, such as application programs, device
`drivers, system services, and other components. The object
`oriented database is platform-independent and is therefore
`con?gured to be hosted on several different operating sys
`tems and computing platforms.
`
`Tennent, Principles of Programming Languages, Prentice
`Hall 1981, pp. 9—33.
`
`20 Claims, 11 Drawing Sheets
`
`[\
`
`\
`
`\
`
`Compilation
`348
`
`'nteémed'ate
`cm
`350
`
`Database Population
`352
`
`Grammatical Form
`w
`
`Transformation Customizer
`
`Serialization
`
`Object-Oriented
`Con?guration Database
`m
`
`Grammar
`%
`
`Page 1 of 24
`
`GOOGLE EXHIBIT 1021
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 1 0f 11
`
`US 6,298,354 B1
`
`100 \
`
`l/O
`11_0
`
`CPU
`22
`
`Memory
`*—’ m
`
`‘
`
`ROM
`m
`
`Network
`1%
`
`FIG. 1
`(PRIOR ART)
`
`Page 2 of 24
`
`

`

`U.S. Patent
`
`Oct. 2, 2001
`
`Sheet 2 of 11
`
`US 6,298,354 B1
`
`(LYVYOled)¢UA
`uoeAer
`soeaer
`
`
`
`soeaer
`
`giz
`
`Jaydepy
`
`2912
`
`Jaydepy
`
`Q912¢
`
`sO
`
`aleMpleH
`
`POLZ
`
`
`
`aemMpleyaleMpleH
`
`9012Goble
`
`Ibe
`
`SOQZLz
`
`Jaydepy
`
`BOLZ
`
`Jasmolg
`
`vLZ
`
`TAASO
`
`aempley
`
`2OLZ
`
`
`
`aulyoRWJenuiABaer
`
`aoepaju|Bulod
`
`0zz
`
`zz
`
`suoneoiddy BeuoeA
`SOJayjewsSOdoj}seqJasMolgeuowaereuoears
`
`
`
`ZETSOESSEIDJOUIO
`
`877Sesse|DUOISUa}XypPrepue}Seres
`
`
`
`
`P2ZSOSSE|Dosegener
`
`
`
`(sjejddyBulpnjoul)
`
`9€z%
`
`
`
`vez(S)IidVJOWIO
`
`0€Z(S)ldUOIsUa}xyprepuegener
`
`
`
`
`9zz(S)Idveseqener
`
`Page 3 of 24
`
`Page 3 of 24
`
`

`

`U.S. Patent
`
`Oct. 2, 2001
`
`Sheet 3 of 11
`
`US 6,298,354 B1
`
`
`
`
`
`
`
`SOSSE|QUOIEUWOJSUBI]BSeqe}eqever
`
`€‘Olasone
`
`uoeAer
`
`euoBaer
`
`SOJ9]/eWsg
`
`euoBAes
`
`SOdo}seq
`
`euoeaer
`
`J9SsmMolg
`
`SOPAEL
`
`Ble
`
`aJeMpleH
`
`POL?
`
`Jae\depy
`
`99LZ2
`
`sO
`
`ILS
`
`aleMpleH
`
`2012
`
`Jajdepy
`
`q9L~
`
`SO
`
`aJeMpleH
`
`Ole
`
`FOLZ
`
`Jasmolg
`
`vLZ
`
`SO
`
`eCLZ
`
`alempley
`
`EQLZ
`
`
`
`aulysew[enuiABaer
`
`soeyeju|Bupod
`
`022
`
`aa
`
`Jojdepy
`
`
`
`(s)I|d\v¥UoHeUOJSUeI]OSegeyegener
`
`
`
`
`
`
`
`
`
`(sjajddyBuipnjour)suojeayddy
`
`Page 4 of 24
`
`9Ez
`
`
`
`(s)idvener
`
`sosse|yBAL
`
`0gz
`
`Page 4 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 4 0f 11
`
`US 6,298,354 B1
`
`NNM 2
`
`w GI
`
`2%)
`
`mix
`
`6% 9% 5:939:80
`
`
`
`63952 oamo?oz
`
`23m
`
`\ 0%
`
`8; E26
`
`com
`
`Page 5 of 24
`
`

`

`U.S. Patent
`
`Oct. 2, 2001
`
`Sheet 5 of 11
`
`US 6,298,354 B1
`
`
`
`sseqejeq
`
`pa}usuQ-slqo—
`
`uoneindoy
`S}JEIPSUS}U|uonejiduwo9
`ose=wio4
`
`
`
`aseqejeguoleinByuo5
`
`Ore
`
`G‘Old
`
`zse
`
`
`
`JOZIWO}SNDUOI}eWJOJsUed|ore
`
`WO/eoewwess
`
`Page 6 of 24
`
`UOHEZIEWES
`
`Ze
`
`vSE
`
`Jee)
`
`pre
`
`Page 6 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 6 0f 11
`
`US 6,298,354 B1
`
`Create grammar
`indentation buffer
`E
`
`l
`
`Create JSD transaction
`to lock tree
`211
`
`1
`
`”
`
`Walk JSD tree
`@
`
`l
`
`Produce grammatical
`output
`5%
`
`Last entry
`reached?
`w
`
`Flush and close
`output ?le
`513
`
`l
`
`Commit JSD transaction
`to unlock tree
`a
`
`FIG. 6
`
`Page 7 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 7 0f 11
`
`US 6,298,354 B1
`
`62 [O
`
`TREE root {
`ENTRY child1 {
`ENTRY grandchild 1 {
`}
`ENTRY grandchildZ {
`}
`ENTRY grandchi|d3 {
`}
`
`}
`ENTRY chi|d2 {
`}
`
`}
`
`f 602
`
`root
`
`604\
`child1
`
`f606
`chi|d2
`
`608 \
`grandchi|d1
`
`[- 610
`grandchi|d2
`
`f 612
`grandchi|d3
`
`FIG. 7
`
`Page 8 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 8 0f 11
`
`US 6,298,354 B1
`
`
`
`EmEoQ 2325.1 > 539m
`
`X 23858
`
`x 23.5w
`
`m .QI
`
`> 3635
`
`/ X b.5605
`
`
`
`585a 2552 E5
`
`X 9356
`
`
`
`
`
`EwEoQ 3.39m EEm
`
`Page 9 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 9 0f 11
`
`US 6,298,354 B1
`
`
`
`
`
`5260 25:5 =$Em== K vi
`
`K NE
`
`3:6: 3:6:
`
`mmEm: 4/ mmEm: 4 /
`N26: N95? ( won
`
`K #2
`
`wmEmc ( OK
`
`“wow
`
`2E0
`
`K NE
`
`
`
`
`
`526m 23:? awe? K @E ,
`
`FwEm: NmEm: v
`
`NwEmc /
`
`
`
`
`
`EmEOO wasp-E8. =u=co= DEM /
`
`FmEmc
`
`m .QI
`
`Page 10 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 10 0f 11
`
`US 6,298,354 B1
`
`I
`
`Start
`
`I
`
`V
`Initialize scratch array of
`intermediate-form entries,
`error condition = no error,
`scope count = zero
`E
`
`No
`
`Compress
`scratch array @
`m
`
`N0
`errors and
`tree has remaining
`tokens?
`E
`Yes
`
`Read a token
`E
`
`Decode
`token type
`E
`
`"{"
`
`"TREE"
`I
`Invoke
`compiIeTree()
`2%
`
`"}"
`I
`Decrement
`scope count
`m
`
`"ATTRIBUTES"
`"ENTRY"
`"PROPERTIES"
`unrecognized
`I
`I
`Compile
`Look for
`properties
`plug-in
`m
`g
`
`V
`Increment
`scope count
`E
`
`V
`Invoke
`compiIeEntry()
`E
`
`Compile
`attributes
`E
`
`FIG. 10
`
`Page 11 of 24
`
`

`

`U.S. Patent
`
`0a. 2, 2001
`
`Sheet 11 0f 11
`
`US 6,298,354 B1
`
`770 —\
`
`compile()
`
`f 772
`
`Initialize temporary array of independent-form entries
`
`compileTree()
`
`compileEntry()
`
`f 774
`/. 776
`
`f 778
`
`Compile the properties, attributes,
`and child entries of each entry
`
`Finalize and compress the independent form
`
`FIG. 11
`
`Page 12 of 24
`
`

`

`US 6,298,354 B1
`
`1
`MECHANISM AND PROCESS TO
`TRANSFORM A GRAMMAR-DERIVED
`INTERMEDIATE FORM TO AN
`OBJECT-ORIENTED CONFIGURATION
`DATABASE
`
`CROSS-REFERENCE TO RELATED
`APPLICATIONS
`
`2
`cies and relationships among objects in an object-oriented
`database complicate the issue of storage and often result in
`large, bloated database ?les Which store unnecessary infor
`mation.
`One speci?c type of database is a database employed by
`an operating system to maintain con?guration information
`that relates to components of softWare and/or hardWare of a
`computer system. For example, such a con?guration data
`base may store con?guration information relating to appli
`cation programs, hardWare devices Which are coupled to the
`computer system, and/or elements of the operating system.
`These con?guration databases may be implemented in many
`different Ways. To exploit the advantages of the object
`oriented paradigm, con?guration databases may be imple
`mented as object-oriented databases. Unfortunately, these
`con?guration databases, object-oriented or otherWise, are
`associated With the same dif?culties as other types of data
`base systems. For instance, if information in a con?guration
`database is generated dynamically upon the start-up of a
`computer system, then that information Will be lost from
`session to session unless it is stored in a convenient Way.
`Therefore, it is desirable to provide an intelligent mecha
`nism and process for storing an object-oriented con?gura
`tion database.
`
`SUMMARY OF THE INVENTION
`The problems outlined above are in large part solved by
`various embodiments of a method and system for transform
`ing an intermediate form of an object-oriented database into
`an active object-oriented database in accordance With the
`present invention. In one embodiment, the intermediate form
`is derived from a grammatical form of an object-oriented
`database. A grammatical form, an expression of an object
`oriented database in a textual form according to a grammar,
`may be stored in a persistent form such as one or more ?les
`on disk. The grammatical form is human-readable and
`human-editable. The grammatical form can be created by
`hand, or it can be created from an object-oriented database
`in transient form through the process of serialiZation. The
`grammar is designed to be platform-independent and
`programming-language-independent and therefore descrip
`tive of any hierarchical object-oriented database.
`In one embodiment, the intermediate form is generated
`from the grammatical form through the process of compi
`lation. In one embodiment, the intermediate form comprises
`an array of entry objects as Would be found in the object
`oriented database. The entry objects are intelligent: they
`encapsulate data With methods for manipulating that data.
`The methods include creating a database entry, creating a
`property associated With an entry, creating an attribute
`associated With an entry or property, querying the last entry,
`property, or attribute created, and ?naliZing entry storage.
`The intermediate form comprises entries as in the object
`oriented database but lacks the infrastructure of the data
`base: for instance, the intermediate form is not accessible by
`application programs as the database is.
`In one embodiment, the intermediate form can be used to
`populate the object-oriented database With entries. Popula
`tion takes place through a public API for accessing the
`object-oriented database; in other Words, through interfaces
`Which declare methods for navigating the database and
`adding entries to the database. In one embodiment, both
`compilation and database population are initiated When a
`grammatical form embodied in a JavaTM object called a
`StaticTree is passed to a JavaTM object called a StaticTree
`Populator.
`In various embodiments, the invention further provides a
`database transformation system and method Wherein an
`
`This application is related to US. patent application Ser.
`No. 09/253,840, ?led on Feb. 19, 1999, entitled “AN
`INTELLIGENT OBJECT-ORIENTED CONFIGURATION
`DATABASE SERIALIZER”; US. patent application Ser.
`No. 09/253,841, ?led on Feb. 19, 1999, entitled “PROCESS
`FOR TRANSFORMING CONFIGURATION DATABASE
`GRAMMAR INTO INTERMEDIATE FORM THAT SIM
`PLIFIES DATABASE GENERATION”; US. patent appli
`cation Ser. No. 09/253,866, ?led on Feb. 19, 1999, entitled
`“GRAMMAR TO REPRESENT A HIERARCHICAL
`OBJECT-ORIENTED DATABASF”; US. patent applica
`tion Ser. No. 09/253,867, ?led on Feb. 19, 1999, entitled
`“TRANSFORMATION CUSTOMIZER FOR CONFIGU
`RATION DATABASE COMPILATION AND SERIALIZA
`TION PROCESSES”; US. patent application Ser. No.
`09/253,868, ?led on Feb. 19, 1999, entitled “AN INTEL
`LIGENT INTERMEDIATE STATE OF AN OBJECT
`ORIENTED DATABASE”; US. patent application Ser.
`Nos. 09/079,501; 09/079,042; 09/079,500; 09/079,103;
`09/079,102; 09/079,499; 09/079,043; and 09/107,048,
`Which are all incorporated herein by reference.
`
`10
`
`15
`
`25
`
`30
`
`BACKGROUND OF THE INVENTION
`
`1. Field of the Invention
`This invention relates generally to computer softWare and
`database systems. More particularly, the invention relates to
`object-oriented databases and computer languages.
`2. Description of the Related Art
`Database systems are serving increasingly important roles
`in today’s society. Modern database systems enable users to
`gather, manipulate, and maintain massive amounts of infor
`mation. A mere handful of examples of the myriad uses of
`database systems includes computeriZed library systems,
`automated teller machines, ?ight reservation systems, com
`puteriZed parts inventory systems, and con?guration data
`bases for computer systems and netWorks.
`Nevertheless, database systems are often dif?cult to main
`tain. Relational databases, for example, though poWerful, are
`often accessible only through complicated, formal queries in
`languages such as SQL (Structured Query Language). It is
`expensive to hire or train experts With pro?ciency in such a
`highly technical ?eld. Storage is also a problem, as data ?les
`in a database can become large and unWieldy, consuming
`?nite storage resources. It is therefore an important consid
`eration that a database system be easy to administer, and that
`the data be easy to enter, retrieve, edit, and store.
`Some database systems are implemented using object
`oriented techniques. Object-oriented databases, like the
`object-oriented programming model, are based on objects:
`units that combine or encapsulate both data and related
`methods for operating on that data. Often, objects are related
`to one another in a class hierarchy Which alloWs related
`objects to inherit attributes from one another. Object
`oriented databases thus provide more accurate modeling of
`“real-World” entities. HoWever, object-oriented databases
`are often just as dif?cult to implement, employ, and maintain
`as other types of databases. Furthermore, the interdependen
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`Page 13 of 24
`
`

`

`US 6,298,354 B1
`
`3
`active object-oriented database is serialized into a persistent
`form Which is described by a grammar, Wherein the
`persistent, grammatical form is compiled into an intelligent
`intermediate form, and Wherein serialization and compila
`tion may be modi?ed to accept compleX data types.
`In one embodiment, the object-oriented database is an
`object-oriented con?guration database Which stores con?gu
`ration parameters pertaining to the softWare and hardWare of
`a computer system, such as application programs, device
`drivers, system services, and other components. In one
`embodiment, the object-oriented database is a platform
`independent one, such as the JavaTM System Database, and
`is therefore con?gured to be hosted on several different
`operating systems and computing platforms. In one
`embodiment, database transformation according to the
`present invention is implemented as a package of classes and
`interfaces in the object-oriented JavaTM Language.
`BRIEF DESCRIPTION OF THE DRAWINGS
`Other objects and advantages of the invention Will
`become apparent upon reading the folloWing detailed
`description and upon reference to the accompanying draW
`ings in Which:
`FIG. 1 is an illustration of a computer system in one
`embodiment.
`FIG. 2 is an illustration of the JavaTM Platform and the
`relationships betWeen the elements thereof in one embodi
`ment.
`FIG. 3 is an illustration of the J avaTM Platform including
`JavaTM Database Transformation functionality in one
`embodiment of the invention.
`FIG. 4 is an illustration of a default hierarchy of the
`JavaTM System Database in one embodiment of the inven
`tion.
`FIG. 5 is a block diagram illustrating an overvieW of the
`transformation of an object-oriented database to and from a
`grammatical form in one embodiment of the invention.
`FIG. 6 is a ?oWchart illustrating serialiZation in one
`embodiment of the invention.
`FIG. 7 is an illustration of the correspondence betWeen a
`grammatical form and an object-oriented form of a database
`in one embodiment of the invention.
`FIG. 8 is an illustration of property domains and attribute
`domains in the grammar provided by one embodiment of the
`invention.
`FIG. 9 is a further illustration of property domains and
`attribute domains in the grammar provided by one embodi
`ment of the invention.
`FIG. 10 is a ?oWchart illustrating compilation in one
`embodiment of the invention.
`FIG. 11 is a diagram illustrating nested blocks Within the
`compilation method in one embodiment of the invention.
`While the invention is susceptible to various modi?ca
`tions and alternative forms, speci?c embodiments thereof
`are shoWn by Way of eXample in the draWings and Will
`herein be described in detail. It should be understood,
`hoWever, that the draWings and detailed description thereto
`are not intended to limit the invention to the particular form
`disclosed, but on the contrary, the intention is to cover all
`modi?cations, equivalents and alternatives falling Within the
`spirit and scope of the present invention as de?ned by the
`appended claims.
`DETAILED DESCRIPTION OF THE
`INVENTION
`Turning noW to the draWings, FIG. 1 is an illustration of
`a typical, general-purpose computer system 100 Which is
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`4
`suitable for implementing database transformation in accor
`dance With the present invention. The computer system 100
`includes at least one central processing unit (CPU) or
`processor 102. The CPU 102 is coupled to a memory 104
`and a read-only memory (ROM) 106. The memory 104 is
`representative of various types of possible memory: for
`eXample, hard disk storage, ?oppy disk storage, removable
`disk storage, or random access memory
`As shoWn
`in FIG. 1, typically the memory 104 permits tWo-Way
`access: it is readable and Writable. The ROM 106, on the
`other hand, is readable but not Writable. The memory 104
`and/or ROM 106 may store instructions and/or data Which
`implement all or part of the database transformation system
`and method described in detail beloW, and the memory 104
`and/or ROM 106 may be utiliZed to install the instructions
`and/or data. In various embodiments, the computer system
`100 may comprise a desktop computer, a laptop computer,
`a palmtop computer, a netWork computer, a personal digital
`assistant (PDA), an embedded device, a smart phone, or any
`other computing device Which may eXist noW or Which may
`be developed in the future.
`The CPU 102 may be coupled to a netWork 108. The
`netWork 108 is representative of various types of possible
`netWorks: for eXample, a local area netWork (LAN), Wide
`area netWork (WAN), or the Internet. Database transforma
`tion in accordance With the present invention may therefore
`be implemented on a plurality of heterogeneous or homo
`geneous netWorked computer systems 100 through one or
`more netWorks 108. The CPU 102 may acquire instructions
`and/or data for implementing database transformation in
`accordance With the present invention over the netWork 108.
`Through an input/output bus 110, the CPU 102 may also
`coupled to one or more input/output devices that may
`include, but are not limited to, video monitors or other
`displays, track balls, mice, keyboards, microphones, touch
`sensitive displays, magnetic or paper tape readers, tablets,
`styluses, voice recogniZers, handWriting recogniZers,
`printers, plotters, scanners, and any other devices for input
`and/or output. The CPU 102 may acquire instructions and/or
`data for implementing database transformation in accor
`dance With the present invention through the input/output
`bus 110.
`In implementing database transformation, the computer
`system 100 eXecutes one or more computer programs. The
`computer programs may comprise operating system or other
`system softWare, application softWare, utility softWare,
`JavaTM applets, and/or any other sequence of instructions.
`An operating system performs basic tasks such as recogniZ
`ing input from the keyboard, sending output to the display
`screen, keeping track of ?les and directories on the disk, and
`controlling peripheral devices such as disk drives and print
`ers. The operating system or other system softWare may also
`include a J avaTM System Database (JSD) on particular
`JavaTM-enabled computer systems, as Will be described in
`detail beloW. Application softWare runs on top of the oper
`ating system and provides additional functionality. Because
`applications take advantage of services offered by operating
`systems, and because operating systems differ in the services
`they offer and in the Way they offer the services, an appli
`cation must usually be designed to run on a particular
`operating system. The computer programs are stored in a
`memory medium or storage medium such as the memory
`104 and/or ROM 106, or they may be provided to the CPU
`102 through the netWork 108 or I/O bus 110.
`As Will be described in further detail beloW, the computer
`system 100 implements a system and method for transform
`ing a grammar-derived intermediate form to an object
`
`Page 14 of 24
`
`

`

`US 6,298,354 B1
`
`5
`oriented con?guration database through the process of data
`base population. In various embodiments, the computer
`system 100 further implements a database transformation
`system and method Wherein an active object-oriented data
`base is serialized into a persistent form Which is described by
`a database description grammar, Wherein the persistent,
`grammatical form is compiled into an intelligent interme
`diate form, and Wherein serialiZation and compilation may
`be modi?ed to accept complex data types. The persistent
`form may comprise one or more containers. Containers may
`reside in various forms in the memory 104 on one or more
`computer systems 100. The database transformation pro
`cesses may also be referred to as the pushing and pulling of
`content to and from containers. The pushing and pulling may
`take place to and from the memory 104, over the netWork
`108, and/or over the I/O bus 110.
`As used herein, an object-oriented database is a database,
`database system, database management system, electronic
`?ling system, or other computeriZed collection of informa
`tion Which stores items of data as objects. An object typi
`cally includes a collection of data along With methods for
`manipulating that data. In one embodiment, the database is
`a con?guration database. As used herein, a con?guration
`database is a database, database system, database manage
`ment system, electronic ?ling system, or other computeriZed
`collection of information Which stores information relating
`to the components and/or parameters Which characteriZe a
`computer system or systems.
`In one embodiment, the database is implemented using
`the resources of the object-oriented JavaTM Platform and the
`object-oriented J avaTM Language. Furthermore, database
`transformation is provided via one or more programming
`interfaces, also knoWn as application programming inter
`faces or APIs. As used herein, an API is a set of routines,
`protocols, methods, variables, tools, “building blocks,” and/
`or other resources for building softWare applications.
`Therefore, a single API or package of APIs can actually
`comprise a plurality of APIs of lesser scope. In one
`embodiment, the database transformation APIs comprise
`object-oriented interfaces and classes developed in the
`J avaTM Language. These database transformation APIs pro
`vide database transformation in accordance With the present
`invention to JavaTM applications Which utiliZe the APIs as
`“building blocks.”
`The J avaTM Language is described in The Java Language
`Speci?cation by Gosling, Joy, and Steele (Addison-Wesley,
`ISBN 0-201-63451-1), Which is incorporated herein by
`reference. The JavaTM Language is an object-oriented pro
`gramming language. In an object-oriented programming
`language, data and related methods can be grouped together
`or encapsulated to form an entity knoWn as an object. The
`object is the fundamental building block of object-oriented
`programming. The data structures Within an object may
`alternately be referred to as the object’s state, its attributes,
`its ?elds, or its variables. In the J avaTM Language, the data
`structures are normally referred to as the variables of the
`object. If the object represents a telephone, the variables
`may include a telephone number, a color and a type (e.g.,
`touch-tone or pulse). The procedures Which operate on the
`variables are referred to in JavaTM as the methods of the
`object. In the telephone example, the methods could include
`ringing, receiving a call or placing a call. These methods Will
`be discussed in more detail beloW. The variables and meth
`ods of an object may all be referred to as the members of the
`object.
`In object-oriented programming, the grouping together of
`the variables and methods Within an object is referred to as
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`6
`encapsulation. When the variables relating to an object and
`the methods Which might affect the object are encapsulated
`Within the object, other entities usually do not have direct
`access to these data and procedures. The other entities
`instead call on the object itself to invoke its oWn methods
`and thereby operate on its oWn data. The encapsulation of
`the members of the object thereby provides some protection
`for the data Within the object and prevents unauthoriZed,
`unWanted, or unintended manipulation of the data. This is
`sometimes referred to as data hiding. (The concept of data
`hiding through encapsulation should be distinguished from
`the hiding of variables in JavaTM variable declarations, as
`explained in more detail beloW).
`If a user Wants to hide the data Within an object, the
`variable Which contains the data is made private. Private
`variables Within an object may only be accessed by the
`methods of the object. Because it may, in some cases, be
`inconvenient or impractical to require manipulation of cer
`tain data through the methods of the associated object, some
`variables may be made public. These public variables are
`directly accessible to entities other than the object With
`Which the variables are associated. Thus, in practice, the
`variables Within objects normally comprise some Which are
`hidden or inaccessible and some Which are public.
`All objects in an object-oriented programming system
`belong to a class, Which can be thought of as a category of
`like objects Which describes the characteristics of those
`objects. Each object is created as an instance of the class by
`a program. The objects may therefore be said to have been
`instantiated from the class. The class sets out variables and
`methods for objects Which belong to that class. The de?ni
`tion of the class does not itself create any objects. The class
`may de?ne initial values for its variables, and it normally
`de?nes the methods associated With the class (i.e., includes
`the program code Which is executed When a method is
`invoked.) The class may thereby provide all of the program
`code Which Will be used by objects in the class, hence
`maximiZing re-use of code Which is shared by objects in the
`class.
`Classes in the J avaTM Language may be hierarchical. That
`is, some classes may be subclasses of a higher class, also
`knoWn as a superclass. For example, in addition to the
`telephone class (i.e., superclass) above, subclasses may be
`created for mobile phones and speaker phones. An object
`Which is instantiated from the mobile phone class Will also
`be an object Within the telephone class. It may therefore be
`treated as belonging to the narroWer class of only mobile
`phones, or it may be treated as belonging to the broader class
`of telephones in general. In the J avaTM Language, the
`subclass (e.g., mobile phones) is said to extend the super
`class (e.g., telephones). Alternatively, the superclass is said
`to be extended by the subclass. For the purposes of this
`disclosure, a subclass is considered to extend all or any of
`the classes Which are above it in the hierarchy. It may also
`be said that the subclass directly extends the class immedi
`ately above it in the hierarchy, and indirectly extends higher
`classes in the hierarchy. For example, if a parent class is
`extended by a ?rst subclass and that subclass is in turn
`extended by a second subclass, the second subclass can be
`said to extend the parent class as Well as the ?rst subclass.
`This terminology Will also be applied to the hierarchical
`structure of interfaces, Which Will be described in more
`detail beloW.
`This hierarchical de?nition of classes and subclasses
`based on shared variables and methods is very useful. A
`subclass includes all the variables and methods in the class
`of Which it is a member (its parent class). The subclass is
`
`Page 15 of 24
`
`

`

`US 6,298,354 B1
`
`7
`said to inherit the variables and methods of its parent class.
`This property is useful in de?ning subclasses because only
`those variables and methods Which do not appear in the
`parent class need to be de?ned in the subclass (although
`variables or methods Which appear in the parent class may
`be rede?ned in the subclass.) This alloWs the code Written in
`the parent classes to be reused so that the programmer does
`not have to reWrite or cut and paste code into each neW
`subclass. Methods that are de?ned in the parent class may,
`hoWever, be rede?ned in subclasses. This is referred to as
`overriding or hiding the previously de?ned method(s). By
`rede?ning a variable Which has already been de?ned in a
`superclass, the programmer may hide the previously de?ned
`variable (Which is distinct from the object-oriented data
`hiding concept inherent in encapsulation). In some object
`oriented languages, subclasses may inherit variables and
`methods from several classes. This is called multiple inher
`itance. If a subclass can only inherit from one parent class,
`this is called single inheritance. The JavaTM Language is
`characteriZed by single inheritance, not multiple inheritance.
`This hierarchical class structure also alloWs the program
`mer to take advantage of a property referred to as polymor
`phism. Polymorphism is a mechanism by Which various
`objects may be handled in the same Way externally, even
`though there are differences in the Way they are handled
`internally. In other Words, the interface Which the different
`objects present to an external entity is the same for each
`object, but the details of each object’s implementation may
`vary. This alloWs objects instantiated from different sub
`classes to be handled identically even though the subclasses
`are not identical. For example, assume that a draWing
`program implements a class for shapes, a subclass for
`circles, and a subclass for squares, each of Which has a
`method called draW(). While draW() Will be implemented
`differently for the circle subclass and the square subclass, the
`draWing program does not have to knoW the details of hoW
`a shape Will be draWn, or even Which of the shapes is to be
`draWn. The draWing program simply calls the draW() method
`for the object to be draWn and the implementation de?ned in
`the object’s class Will be used.
`Another important element of the J avaTM Language is the
`interface. Interfaces are closely related to classes. Interfaces
`may declare What classes do, but not hoW they do it. For
`example, in the case of the telephone class above, an
`interface Would declare that a telephone could ring, place
`calls, and receive calls, but it Would not de?ne the Way in
`Which this Was accomplished. Atelephone class, on the other
`hand, Would set out the functions that de?ne each of these
`actions so that When a telephone is instantiated, it can
`actually ring, place a call, or receive a call (in the context of
`the application). An interface may declare methods and/or
`constants. To utiliZe an interface, one or more classes must
`implement the interface.
`The JavaTM Platform Which utiliZes the object-oriented
`J avaTM Language is a softWare platform for delivering and
`running the same applications on a plurality of different
`operating systems and hardWare platforms. As Will be
`described in further detail beloW, the J avaTM Platform
`includes system-dependent portions and system
`independent portions, and therefore the JavaTM Platform
`may be thought of as having multiple embodiments. The
`JavaTM Platform sits on top of these other platforms, in a
`layer of softWare above the operating system and above the
`hardWare. FIG. 2 is an illustration of the JavaTM Platform
`and the relationships