US 5,878,260 AGrant
Information Handling System, Method, and Article of Manufacture Including Object Name Services With Multilevel Indices
Issue Date:1999-03-02
•17 Claims
•3 Drawing Sheets
Abstract
A prior art naming module supports binding of an object to a name in a Naming Context (i.e., a directory). The present invention extends this original module to support properties (data about bindings), searching (finding bindings given constraints on properties) and indexing (for speeding up the search on certain property names). The ExtendedNamingContext (ENC) is a subclass of the OMG NamingContext (NC) that introduces properties, searching and indexing.
Metadata
Assignee
- International Business Machines Corporation
Inventors
- George Prentice Copeland
- Vinoj Narayan Kumar
Application Information
Application Number:US 5540631
Filing Date:1995-11-06
Priority Date:1995-11-06
Art Unit:272
Classifications
IPC:
G06F 944G06F 1730
Field of Search:
395707702;614;670;683103
Patent Drawings (3 sheets)
Description
Technical Field of the Invention
The present invention relates to information handling systems, methods and articles of manufacture, and more particularly to information handling systems and methods for implementing object name services in an object oriented system.
Background of the Invention
A related copending application (Ser. No. 08/537,648 AT995-092) teaches and claims an information handling system, method and article of manufacture for automatically inserting object services such as persistence, concurrency, recoverability, security and distribution into binary classes in an information handling system employing object oriented technology. The related invention includes registering a description of a class in a name service context, and searching the name service context for a class object referred to as a factory, among other elements of the invention.
To accomplish the goals of the related invention, an object name service is needed. The name service should have the following characteristics:
1. Support binding objects to names;
2. Support associating properties with an object binding;
3. Support properties per binding or properties across bindings for an object;
4. Support searching for objects based on object properties;
5. Support multilevel searches; and
6. Support indexing to permit scaling to large numbers of objects and properties.
Prior Art
In the prior art there are many techniques for improving object oriented programming systems (OOPS).
The following are examples of the prior art.
U.S. Pat. No. 5,093,914 generally teaches a method used by a digital computer in controlling execution of an object oriented program to effect a defined action, for example, stopping the program when a specified virtual function is invoked on a specified object during execution of the program.
Although the patent generally deals with methods for controlling execution of object oriented programs, the patent does not teach nor suggest automatically inserting object services into binary classes in an object oriented system as is taught and claimed herein with reference with the present invention.
U.S. Pat. No. 5,343,554 teaches a computing system in which problems are solved by a process which includes creating objects of first and second classes wherein the second class objects are externally invocable and where the externally invocable sub-class objects include an indication of an internally invocable sub-class object and executing the class of objects wherein one externally invocable sub-object invokes the internally invocable sub-object and a new object of the first class is generated in response to the results.
Although the patent deals generally with the use of object oriented systems including classes and sub-classes for solving problems, the patent does not teach nor suggest automatically inserting object services into binary classes in an object oriented system as is taught and claimed herein with reference with the present invention.
There is a need to automatically add object services features, for example, persistence, recoverability, concurrency and security to a binary class. Sometimes the source code of a class is not available for modification. Even when the source code is available, a considerable reprogramming effort is required to add the object services features.
A user should be able to add object services features in a way that does not increase the size of the users class diagram with many variations on the original class. The user should be able to specify these object services features as constraints along with constraints that describe the function of the class when searching for the class.
An overall goal in object oriented programming systems is the development of program objects which can be reused easily.
The importance of binary code over source code increases with the degree of reuse. A main purpose of object oriented technology is code reuse. For object oriented technology to achieve large scale success, binary code reuse is essential. As the state of the art moves towards applications built from object formats which can be tailored and plugged into each other, binary code is critical.
The Object Management Group (OMG) is currently defining a set of interfaces for object system services named Common Object Services.
Summary of the Invention
It is an object of the present invention to provide a name service which supports searching and indexing in an object oriented information handling system.
Accordingly, a system and method in an information handling system employing object oriented technology, includes means for extending a naming context module to support properties (data about bindings), searching (finding bindings given constraints on properties) and indexing (for speeding up the search on certain property names). The ExtendedNamingContext (ENC) is a subclass of a NamingContext (NC) that introduces properties, searching and indexing.
It is an advantage of the present invention that object properties, searching and indexing can be efficiently incorporated in a naming context module in an information handling system.
Brief Description of the Drawings
FIG. 1 is a block diagram of a system for executing the method according to the present invention.
FIG. 2 is a block diagram showing the operating system platform and system object model program supporting the present invention.
FIG. 3 is a diagram of extended naming context objects with properties bound to other objects in accordance with the present invention.
FIG. 4 is a diagram of extended naming context objects with an index bound to other objects in accordance with the present invention.
FIG. 5 is a diagram of an object bound in more than one extended naming context objects with shared properties in accordance with the present invention.
Detailed Description of a Preferred Embodiment of the Invention
Referring now to FIGS. 1 and 2, on information handling system 10 and an operating system environment for the present invention will be described.
Information handling system 10 may be a graphics work station or the like with a very powerful processor 12, a storage system 14, a system bus 16, display sub-system 18 controlling a display device 20, a cursor control device 22, and an I/O controller 24, all connected by system bus 16. The information handling system 10, shown in FIG. 1 may be operated by a commercially available well known multitasking operating system such as OS/2* (OS/2 is a registered trademark of International Business Machines Corporation). Among many tasks which the OS/2 operating system controls an operating information handling system 10, is execution of a program SoMobjects, which is a commercially available product of International Business Machines Corporation.
The method and article of manufacture of the present invention may be incorporated in the SOMObjects program.
The original OMG Naming module supports binding of an object to a name in a Naming Context (i.e., a directory). The present invention extends this original module to support properties (data about bindings), searching (finding bindings given constraints on properties) and indexing (for speeding up the search on certain property names). The ExtendedNamingContext (ENC) is a subclass of the OMG NamingContext (NC) that introduces properties, searching and indexing. An example of the extension is listed below:
Referring now to FIG. 3, the operations that do a binding (bind, rebind, bind.sub.-- context, bind.sub.-- new.sub.-- contest, rebind.sub.-- context, bindWithProperties, bindContextWithProperties, rebindWithProperties, rebindContextWithProperties) will be described.
1. Create a container object in the same server (process) as the target ENC. The container object has the following state:
a) sequence<ENC>parents; /* init to empty */
b) unsigned long max.sub.-- distance.sub.-- to.sub.-- index; /* init to 0 *,
c) sequence<Property>properties; /* init to empty */
d) Object object; /* init to null object */
2. Within the ENC, associate the container with the name to be bound;
3. Add the target ENC to the container's parents;
4. container.fwdarw.object=the object to be bound;
Referring now to FIG. 4, the operation to add an index (addIndex) will be described:
1. For each name in the target ENC, ask its container to
1.1 update its max.sub.-- distance.sub.-- to.sub.-- index;
1.2 relay the request to get index information (typed values of properties with the index's property name and the ENC that contains it) to the container. (This private operation includes the property name, the distance parameter and how far it is from the index. The recursion stops when the distance parameter and how far it is from the indexes are equal. The index information is accumulated upon returning at each level of the recursion.)
2. Using the recursively accumulated index information, build an index in the target ENC.
The max.sub.-- distance.sub.-- to.sub.-- index allows the container object and ENC to know how far relay changes to properties that might affect an index, and the parents list allows them to know to whom to send this information.
The operations that add properties or change their values (addproperty, addproperties, bindWithProperties, bindContextWithProperties, rebindWithPropertis, rebindContextWithProperties, removeProperty, removeSomeProperties, removeAllProperties) includes the following implementation:
1. Resolve the name within the target ENC to the container;
2. Add the input properties to the container's properties;
3. For each parent in the container's parents, tell the parent to update its index (this private operation includes the changed properties and the max.sub.-- distance.sub.-- to.sub.-- index, which is decremented for each relay until zero when the relays can stop);
The operations that get the names of properties or the properties (listProperties, getproperties, getSomeProperties, getAllProperties, getObjectAndProperties, getobjectAndSomeProperties, getobjectAndAllProperties) include the following implementation:
1. Resolve the name within the target ENC to the container;
2. Return container.fwdarw.properties and/or container.fwdarw.object;
The resolve operator includes the following implementation:
1. Resolve the name within the target ENC to the container;
2. Return container.fwdarw.object;
Referring now to FIG. 5, the operations that create a shared object and its properties (bindWithSharedProperties, rebindWithSharedProperties) will be described:
1. shared.sub.-- container=resolve the source name within the source ENC to the container;
2. Within the target ENC, associate the shared.sub.-- container with the target name;
3. Add the target ENC to the shared.sub.-- container's parents;
4. Any indexes in the target ENC or above must be updated (to do this, use a combination of the above algorithms to get the index information below and update the indexes above);
The unbind operator includes the following implementation:
1. Resolve the name within the target ENC to the container;
2. Remove the target ENC from the container's parents;
3. If the container's parents is empty, deallocate the container.
It will be appreciated that although a specific embodiment of the present invention has been described herein for the purposes of illustration, various modifications may be made without departing from the spirit or scope of the invention.
Accordingly, the scope of this invention is limited only by the following claims and their equivalents.
Claims
What is claimed is:
1. An information handling system, comprising: one or more processors; a storage system; one or more I/O controllers; a system bus connecting the processors, the storage system and the I/O controllers; an operating system program for controlling operation of the information handling system; and an object based program operating in association with the operating system program for controlling execution of program modules represented by one or more objects, the object based program having; means for creating an extended naming context object and container object hierarchically related to said extended naming context object, said container object including a plurality of properties, each of said properties including an identifier and a value; and means for searching said container object in response to a request received in said extended naming context for objects that satisfy a specified condition expressed in terms of properties; means for returning to a search requester all objects satisfying the specified condition.
2. A system according to claim 1, wherein the object based program further comprises: means for associating a container object with a name to be bound.
3. A system according to claim 1, wherein the object based program further comprises: means for adding an index to an extended naming context object said index containing values for said for properties in said container objects.
4. A system according to claim 3, wherein the means for adding an index further comprises: means for controlling a maximum number of levels between a request and an index.
5. A system according to claim 1, wherein the object based program further comprises: means for creating one or more extended naming context objects having shared properties.
6. A system according to claim 5, wherein the means for creating one or more objects having shared properties further comprises: means for resolving a first object name in a first extended naming context object to a container object; means for associating the container object with a second object name; means for adding a second object to a parent list in the container object; means for locating each index that would identify the second object; and means for updating each located index in any associated extended naming context object.
7. A computer readable medium, having program logic recorded the computer readable medium managing an extended naming context, comprising: program logic means for creating a plurality of extended naming context objects each having a first name, program logic means for creating one or more container objects having a state including a plurality of properties, each property having an identifier and a value, each container object being associated with one or more of said extended naming context objects; program logic means for receiving a search request in an extended naming context object, said search request specifying constraints in terms of property identifiers and values; program logic means for searching said container objects by matching said constraints to said properties; program logic means for returning objects meeting said constraints in response to said search request.
8. A computer readable medium, according to claim 7, further comprising: program logic means for setting one or more predetermined properties associated with one or more extended naming context objects.
9. A computer readable medium, according to claim 7, further comprising: program logic means for associating a container object with a name to be bound.
10. A computer readable medium according to claim 7, further comprising: program logic means for adding an index to an extended naming context object, said index being based on said properties.
11. A computer readable medium according to claim 7, further comprising: program logic means for creating one or more objects having shared properties.
12. A computer readable medium, according to claim 7, wherein the program logic means for creating one or more objects having shared properties further comprises: program logic means for resolving a first object name in a first extended naming context object to a container object; program logic means for associating the container object with a second object name; program logic means for adding a second object to a parent list in the container object; program logic means for locating each index that would identify the second object; and program logic means for updating each located index in any associated extended naming context object.
13. A method for improving performance of an object name resolution service, comprising the steps of: creating one or more container objects having a plurality of properties, said properties having an identifier and a value, each container object being associated with one or more extended naming context objects; setting one or more predetermined properties associated with one or more extended naming context objects; receiving a request in an extended naming context object to search for an object meeting a constraint expressed in terms of properties; searching said container objects for ones satisfying said constraints; returning a response to said request to search all objects satisfying said constraints.
14. The method according to claim 13, further comprising the step of: associating a container object with a name to be bound.
15. The method according to claim 13, further comprising the step of: adding an index to each of said extended naming context objects, the index identifying properties in said container objects.
16. The method for improving performance of an information handling system, according to claim 13, further comprising the step of: creating one or more objects having properties shared with another object.
17. The method according to claim 13, wherein the creating one or more objects having properties shared with another object step further comprises the steps of: resolving a first object name in a first extended naming context object to a container object; associating the container object with a second object name; adding a second object to a parent list in the container object; locating each index that would identify the second object; and updating each located index in any associated extended naming context object.