throbber
(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
`
`

`

`Oct. 2, 2001
`
`11f02teehS
`
`US 6,298,354 B1
`
`chomE_m3t_>m>mw
`
`mlwm
`
`momtBEmEton.
`
`0le
`
`
`
`mam?newmew
`
`
`
`533.163224
`
`
`
`mo9N5mo
`
`£5£5
`
`US. Patent
`Cw?KOEn:896..mo3:25mo3:38.3265N:0N>M—aG:0“>65m:0N>NfiGCOfi>fifi
`
`
`
`
`
`
`
`flwmwwflo550mmwmmmfiocoacflxmBancfimm>mwleN33.20mmmmm>mw
`
`flEE<550am.EH28555$23«>2.%@_n_<mwmm«>9.
`
`
`
`QmBEmIEms—Em:wfiBEmI05263:
`wOm>mw§59505
`normoormnormworm
`
`91mmov|§
`
`Wm
`
`
`
`
`
`$5391mcfiaocc2252391
`
`
`
`
`
`Page 3 of 24
`
`

`

`Oct. 2, 2001
`
`11f03teehS
`
`US 6,298,354 B1
`
`
`
`
`
`$5582_m:t_>w>mw
`
`US. Patent
`
`
`
`wmmmfio:oszLchmc.mmmamfiom>m1
` %com8330«>3.
`
`
`mc9950mcml.
`
`0mmmmm>mCE<.#hFaaoaEE<mama
`
`@mm
`
`
`
`
`
`$63949620::mcozmo=na<
`
`%wom>mfi
`
`EmaEmI
`
`norm
`
`:0«>3.
`
`mogfl.
`
`gmflmu<
`
`00_‘N
`
`m0
`
`omrN
`
`BEES—m:
`
`00rm
`
`m03:mem:0«>2.
`
`fl
`
`momtmt:mchn.
`
`a
`
`.9394
`
`85
`
`mo
`
`noNEma—3m:
`
`N:0“>61
`
`monoimoo
`
`mmX532%
`
`$9505
`
`.VIE
`
`wO
`
`mmem
`
`08263:
`
`moFm
`
`32505a:0«>2.
`
`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
`
`

`

`Oct. 2, 2001
`
`Sheet 5 0f 11
`
`US 6,298,354 B1
`
`
`
`
`BEozofimso
`
`
`
`wmmnfimocozfismccoo
`
`Sum
`
`a:ozmufitmw
`
`«mm
`
`EEEEO
`
`vlvm
`
`US. Patent
`
`
`
`c2530.”.mwmnflmo
`
`mm
`
`QmeELmE.
`
`%E8“.
`
`co=m=ano
`
`aim
`
`
`
`558930coszBngL...%
`
`
`
`E5”._moszEE0
`
`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 betWeen the elements thereof in one
`embodiment. The JavaTM Platform has tWo basic parts: the
`JavaTM Virtual Machine 222, and the JavaTM Application
`
`10
`
`15
`
`25
`
`35
`
`45
`
`55
`
`65
`
`8
`Programming Interface (J avaTM API). The J avaTM API may
`

This document is available on Docket Alarm but you must sign up to view it.


Or .

Accessing this document will incur an additional charge of $.

After purchase, you can access this document again without charge.

Accept $ Charge
throbber

Still Working On It

This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.

Give it another minute or two to complete, and then try the refresh button.

throbber

A few More Minutes ... Still Working

It can take up to 5 minutes for us to download a document if the court servers are running slowly.

Thank you for your continued patience.

This document could not be displayed.

We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.

Your account does not support viewing this document.

You need a Paid Account to view this document. Click here to change your account type.

Your account does not support viewing this document.

Set your membership status to view this document.

With a Docket Alarm membership, you'll get a whole lot more, including:

  • Up-to-date information for this case.
  • Email alerts whenever there is an update.
  • Full text search for other cases.
  • Get email alerts whenever a new case matches your search.

Become a Member

One Moment Please

The filing “” is large (MB) and is being downloaded.

Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.

Your document is on its way!

If you do not receive the document in five minutes, contact support at support@docketalarm.com.

Sealed Document

We are unable to display this document, it may be under a court ordered seal.

If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.


Access Government Site

We are redirecting you
to a mobile optimized page.





Document Unreadable or Corrupt

Refresh this Document
Go to the Docket

We are unable to display this document.

Refresh this Document
Go to the Docket