Dynamic mapping of component interfaces

• US 6,438,744 B2
• Filed: 07/15/1998
• Issued: 08/20/2002
• Est. Priority Date: 07/15/1998
• Status: Expired due to Term

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Toutonghi, Michael J., Sharpe, Tracy C.
• Primary Examiner(s): Chaki, Kakali
• Assistant Examiner(s): Vo, Ted T.
• Application Number:
  US09/115,987
• Publication Number:
  US 20020004934A1
• Time in Patent Office: 1,497 Days
• Field of Search: 717/1, 717/4, 717/11, 717/137, 717/106-108, 717/116-118, 717/162-165
• US Class Current: 717/137
• CPC Class Codes: G06F 9/451 Execution arrangements for user interfaces

Abstract

The dynamic mapping from an ActiveX component model to a JavaBean model is disclosed. In one embodiment, an ActiveX compatible object is created at run-time for those JavaBean components that an ActiveX client application wishes to utilize. In another embodiment, upon a call to CoGetClassObject or related methods using class identifiers, a COM-callable wrapper is generated and a mapping table containing COM dispatch identifiers is scanned to ensure the dispatch identifiers are unique. If they are not, the dispatch identifiers associated with JavaBean component interfaces are adjusted to make them unique.

Claims

1. A computerize system comprising:

an operating system providing a first interface structured according to a first object model for controlling a first component structured according to the first object model and a second interface structured according to a second object model for controlling a second component structured according to the second object model, said first interface and said second interface each having methods and properties;

at least one client program utilizing said first interface to invoke a first method on the first component at run-time but instead invoking a second method on the second componet;

a runtime queriable component defined in the second object model; and

a data structure representing a mapping from methods and properties of said first interface to methods and properties of said second interface, said mapping data structure generated at least in part with a query made on the runtime queriable component;

wherein the first object model is different from the second object model.

2. A computerized method form dynamically mapping a first component having an interface defined in accordance with a first object model comprising methods and properties to a second component having an interface defined in accordance with a second object model comprising methods and properties, the computerized method comprising:

receiving a request for the interface of said first component from a third component statically complied to access the interface of said first component;

generating an object representing said first component;

dynamically querying at run-time said second component for its methods properties to create a set of source data;

populating said object with said source data;

providing said requesting third component an interface of said object instead of the interface of said first component; and

executing a method of said second component in response to receiving a request on the interface provided to said third component.

4. A computer-readable medium having computer-executable instructions for performing a method comprising the steps of:

defining a first component having an interface defined in accordance with a first object model comprising methods and properties;

defining a second component having an interface defined in accordance with a second object model comprising methods and properties, said second model being different from said first object model;

generating an object representing said first component;

querying dynamically at run-time said second component for its methods properties to create a set of source data;

populating said object with said source data;

response to receiving a request for said first component interface, providing a reference to said object; and

executing a method of said second component in response to receiving a request on the provided reference to execute a method of said first component.

5. The computer-readable medium of claim 4 further having computer-readable instructions for performing the steps of:

generating a data structure containing a plurality of entries respresenting the mapping between said first component interface and said second component interface, said entries each containing a dynamic method invocation dispatching identifier; and

adjusting said dispatching identifier to eliminate conflicts with the dispatching identifiers in the plurality of entries.

6. A computer comprising:

a processor;

a computer-readable medium; and

an operating system executed by the processor and providing;

a first interface structured accordance with a first object model for controlling a first component and a second interface structured in accordance with a second object model for controlling a second component, said first interface and said second interface each having methods, properties and events, said second object model being different from said first object model;

at least one client program attempting to utilize said first interface to control said first component and controlling instead said second component;

a queriable component defined in the second interface; and

a data structure respresenting a mapping from the methods, properties and events of said first interface to the methods, properties and events of said mapping data structure being generated through queries on the queriable component dynamically during the run-time of the client program.

3. The computerized method of claim 6, further comprising:

generating a data structure containing a plurality of entries respresenting the mapping between said first component interface and said second component interface, said entries each containing a dynamic method invocation dispatching identifier; and

adjusting said dispatching identifier to eliminate conflicts with the dispatching identifiers in the plurality of entries.

7. A method for dynamically mapping run-time requests between components constructed according to different objects models, where a first component constructed according to a first object model requests invocation of a first method of a second component constructed according to the first object model and the request is implemented by a second method of a third component constructed according to a second object model, the method comprising:

receiving a request from the first component to invoke the first method;

obtaining an interface element description of the second component;

dynamically obtaining an interface element description for the methods available on the third component from a queriable interface defined in the second object model; and

dynamically invoking the second method when the first object invokes the first method.

8. A method for dynamically mapping run-time requests between components structured according to different objects models, where a first component structured according to a first object model invokes method on a second component structured according to the first object model and the invoked methods are implemented by methods of a third component constructed accordance with a second object model, the method comprising:

receiving a request from the first component, for a reference to the second component;

obtaining type library information about the second component; and

dynamically invoking a method in the second object model to determine invocable methods available on the third component during the run-time of the first component; and

dynamically mapping a method in the second component to a method in the third component.

9. The method of claim 8, further comprising:

creating a mapping data structure that holds mappings from the first method to the second method; and

returning a reference to the wrapper to the first component.

10. The method of claim 9, further comprising:

maintaining a record holding the reference to the mapping data structure;

receiving a request for a reference to the second component from a next component structured according to the first object model; and

returning to the mapping data structure to said next component.

11. A method for dynamically mapping requests made between components constucted according to a different object models, a run-time environment comprising a type library for discovering type information about components constucted according to the first object model, a forst component defined according to a first object model executing in a client process, the client process further containing an indication that a second component defined according to the first object model is to be implemented by a third component defined according to a second object model, the third component haveing distinguishing type information about it'"'"'s methods and properties discoverable at run-time through methods provided by a fourth components defined according to the second object model, the third and fourth components ant their corresponding methods executing under control of a server process comprising a virtual machine that provides a run-time environment for components defined according to the second object model, the method comprising:

receiving a request from the first component for an instant of the second component;

determining from the type library, the methods and properties provided by the second component;

discovering the methods and properties available for the third component by calling a method of the fourth component;

determining from naming convemtions of the first and second object model, a mapping of methods in the second component to methods in the third component;

dynamically creating a data structure to hold the determining mappings;

receiving a request to execute a method on the second component, and invoking a method of the third component indicated in the data structure.

12. A computerized system comprising:

an operating system providing a first interface for controlling a first component and a second interface for controlling a second component, said first interface and said second interface each having methods and properties;

at least one client program utilizing said first interface to invoke a first method on the first component at run-time but instead invoking a second method on the second component; and

a data structure representing a mapping from methods and properties of said first interface to methods and properties of said second interface, said mapping data structure being dynamically generated during the run-time of the client program;

wherein the first interface is structured differently from the second inteface.