Object interface control system

Details Object interface control system Object interface control system

1997-03-11

2001-10-16

Banankhah, Majid (Department: 2151)

Electrical computers and digital processing systems: multicomput

Computer-to-computer data routing

Least weight routing

C709S241000

Reexamination Certificate

active

06304918

ABSTRACT:

FIELD OF THE INVENTION
This invention relates to the field of object oriented programming languages. In particular, this invention relates to objects based on the Component Object Model (“COM”). The invention provides a means for determining the form of an object's interface as well as the functionality of an object's interface by defining services within which are grouped methods.
PROBLEM
Object-oriented programming or development has become the standard by which most commercial software is developed. By this technique, a method is implemented as an object by bundling together both the data and the procedural code that manipulates the data. Multiple objects interact with one another through their respective interfaces which expose functionality. Objects are classically defined by three characteristics: encapsulation, polymorphism and inheritance. Encapsulation means that only the interface of an object is visible to other objects and the underlying implementation of the object is encapsulated within the object. Polymorphism is the ability for different objects to behave differently to the same message. For example, the “DRAW” command to an object that makes triangles provides a different result than the “DRAW” common to an object that makes circles but the command used with both objects is the same. The triangle object and the circle object are polymorphic through a “shape” interface. Inheritance is an abstraction that allows the similarities of different classes to be described by a common base class.
The Component Object Model (“COM”) is one model that defines an architecture for building objects and, in particular, defines the polymorphism between objects. COM is currently used extensively and its details are well known to those skilled in the art. COM also forms a constituent portion of the Object Linking and Embedding (“OLE”) environment of object-based services. OLE's framework and flexibility is also well understood by those skilled in the art. Currently COM provides for certain communications and operations between objects and objects used in a COM environment must conform to the COM definitions and rules.
The QueryInterface call is the primary mechanism provided by COM for determining which features an object supports. The functionality an object implements is accessed via one or more interfaces designed to expose that functionality. QueryInterface is used to determine what interfaces and hence what functionality an object supports. QueryInterface also must be used to get a pointer to call through an interface even if it is known that the object supports the needed interface. QueryInterface is the only way to get the necessary pointer to an interface for an object. To use the QueryInterface call, a client object passes an Interface ID (“IID”) parameter identifying the requested interface to the server object. If the server object supports the interface, a pointer to that interface on the server object is returned to the client object. An important characteristic of the QueryInterface call is that, by definition, QueryInterface requires object identity. Object identity means that a pointer returned by a server object in response to a QueryInterface call will always be a pointer to an interface of the server object. QueryInterface does not allow the return of a pointer to an interface of a different object.
A problem occurs when there are collisions in the naming of object interfaces. Through independent development of COM objects or as COM or COM-based systems have developed over time, situations can arise where an IID passed in a QueryInterface call conflicts with an IID implemented on the server object and that IID provides a different functionality than expected. In these situations, one must use a different IID in order to distinguish between the different functionalities. For example, a development of COM, called OLE Controls, that was implemented subsequent to the original COM design, added new functionality including a feature known as ambient properties. This functionality was accessed via the IDispatch interface, a generic, polymorphic way to access properties of an object. A container object, such as for a document, has multiple control objects with which it is associated. The container object can have ambient properties, margin settings for example, that each of the control objects needs to be aware of. OLE Controls adopted a convention by which a control object can ascertain the ambient properties of the container object by making an IDispatch call on the container. A QueryInterface call is first made on the container object to get a pointer to the IDispatch interface. Due to independent development of COM containers prior to the standardization of OLE Controls, the IDispatch name had been used by some containers to access a different set of properties and this previously implemented IDispatch interface has nothing to do with ambient properties. The use of the IDispatch IID by two interfaces providing different functionalities conflicts with their desire to expose this functionality in a standard way.
A Querylnterface call does not allow a client object to identify the functionality of the request (e.g. ambient properties) separate from the form, (e.g. IDispatch) that the functionality assumes on the server object. The only guaranteed approach to circumventing the above problem is to always ensure that a new IID is used. This approach is effective but limits the advantages of polymorphism and the reuse of code. Another existing approach is to explicitly design the required functionality into the communication between the client object and the server object. A further solution is where the client object has enough knowledge about the server object to explicitly navigate to the required functionality.
There exists a need for an object interface control system that allows a client object to access more than one functionality through a single interface of a server object without the need to create different interfaces on the server object. There exists a further need to identify both the form of an interface as well as the context in which the interface exists. A further need exists for an object interface control system that provides an QueryInterface-like call without the limitation of object identity.
SOLUTION
The above identified problems, and others, are solved and a technical advance achieved in the field by the object interface control system of the present invention. The present invention provides a method and apparatus for reusing an interface of an object for multiple purposes while maintaining the required characteristics of polymorphism. In general, the present invention provides a QueryInterface-like call that allows the client object to indicate the desired interface and, in addition, to indicate the context in which the call is made. This mechanism returns an object which implements the requested functionality expressed in terms of the desired interface. In effect, the present invention allows a client object to identify the functionality of a call to a server object separate from the form, i.e. the interface, that the functionality is to assume. A result is that a single interface can be reused for multiple purposes by identifying the context of the request. A further result is that object identity does not apply to the function call provided by the present invention. Therefore, the interface returned by the server object may or may not be on the server object itself.
The present invention provides a mechanism for a client object to query a server object to determine if an object, the server object or a different object, supports a particular feature or functionality and where to find the proper interface from which to access the feature. This is similar to the IUnknown interface and the QueryInterface call of COM. However, the QueryInterface call requires that the client object pass only an IID to the IUnknown interface. The IID defines both the functionality or feature of interest and the form or interface at which that functi

Affiliated with

Also associated with

Rating

Object interface control system does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Object interface control system, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Object interface control system will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-2566695