Method and system for providing an event system infrastructure

Details Method and system for providing an event system infrastructure Method and system for providing an event system infrastructure

1999-04-02

2003-04-29

Courtenay, III, St. John (Department: 2126)

Electrical computers and digital processing systems: multicomput

Computer-to-computer data routing

Least weight routing

Reexamination Certificate

active

06557046

ABSTRACT:

TECHNICAL FIELD
The present invention relates generally to computer systems and more particularly to the management of events in computer systems.
BACKGROUND OF THE INVENTION
The Microsoft OLE 2.01 protocol provides a standard way for objects to fire events and provides a connection architecture for connecting event sources with event sinks. The event and connection architectures provided by Microsoft OLE 2.01 are in large part achieved by defining “interfaces.” In Microsoft OLE 2.01, an “interface” is a named set of logically related functions. Each interface lists signatures for a set of functions, but does not provide code for implementing the set of functions; rather, objects provide the code for implementing the functions. Such objects are said to “support” the interfaces for which they provide code.
Microsoft OLE 2.01 specifies a component object model (COM). The component object model is implemented through a set of fundamental application program interface (API) functions and interfaces. The API functions provide for object creation, management and marshalling. A component object is one that complies with certain constraints set forth in COM.
The event architecture enables an event source to source events that are sinked by an event sink. As will be described in more detail below, an event source triggers events on an event sink by calling methods on the event sink. Events are logically grouped into semantically-related event sets, and interfaces are defined for each event set that an event sink wishes to sink. Interfaces are provided to provide a form of registration so that an event sink may register to sink events that are sourced by an event source. The registration occurs on a per-event set basis. The event sink and event source are typically separate processes and may reside on the same machine or on different machines.
The event source exposes connection points to which an event sink may connect. Each connection point is associated with a particular event set and indicates that the event source is ready to source events for the associated event set. A connection point may be connected by multiple connections to multiple event sinks. An event source may have multiple connection points (indicating the willingness of the event source to source multiple instances of event sets). The event source connection point container serves as a container of the connection points. Each connection point is typically implemented as a separate sub-object but need not be. Each connection point is assigned a globally unique identifier (GUID), which is a 128 bit value that uniquely identifies an interface or object.
FIG. 1
is a block diagram showing objects and interfaces supported by the objects that play a central role in the event architecture provided by Microsoft OLE 2.01. In
FIG. 1
, an event sink
10
is connected to both event source
12
and event source
14
. Each of the event sources
12
and
14
is a connection point container that contains respective connection points
16
A,
16
B and
18
A,
18
B. Each of the event sources
12
and
14
supports the IConnectionPointContainer interface. The line with a circle attached to one end that is labeled “IConnectionPointContainer” serves as a graphical indicator to indicate that the object (i.e., event source
12
or
14
) supports the named interface. The IConnectionPointContainer interface is formally defined as:
interface IConnectionPointContainer: public IUnknown
{
HRESULT EnumConnectionPoints (IEnumConnectionPoints
** ppEnum);
HRESULT FindConnectionPoint(REFIID iid, IConnectionPoint
** ppCP);
};
As is apparent from the above definition, the IConnectionPointContainer interface includes two methods. The first method, the EnumConnectionPoints( ) method enumerates the connection points that are contained within the connection point container. Microsoft OLE 2.01 defines a number of enumerator interfaces and methods that enumerate items so that list of items may be communicated and iterated through. This method is an example of such an enumerator method. The result of calling EnumConnectionPoints is that each of the connection points contained in the event source is enumerated. The FindConnectionPoint( ) method returns a connection point that is associated with a particular interface identifier (IID).
Each event set has an associated instance of an interface that the event sink supports. For example, in
FIG. 1
, event sink
10
supports a set of events in the ISomeEvents interface. The ISomeEvents interface includes a number of methods that may be called from a connection point to trigger associated events. Events are triggered by calling the associated method in the event set interfaces that the event sink
10
supports. Multiple connection points may call methods in a common event set interface. For example, in
FIG. 1
, connection point
16
A and connection point
18
A from event sources
12
and
14
, respectively, may trigger calls to methods in the ISomeEvents interface instance that is provided by event sink
10
. Likewise, it should be appreciated that an event sink may support multiple instances of event set interfaces. For example, in
FIG. 1
, the event sink
10
supports instances of both the ISomeEvents interface and the IOtherEvents interface. The event sink
10
supports multiple instances of the IOtherEvents interface. No source identity information is passed on an event invocation. Thus, an event sink must set up a forwarding interface for each source to which it is connected. For example, in
FIG. 1
separate forwarding objects
19
A and
19
B have been registered for the separate instances of the IOtherEvents interface.
Each connection point
16
A,
16
B,
18
A and
18
B supports the IConnectionPoint interface. This interface is formally defined as:
interface XConnectionPoint: public IUnknown
{
HRESULT GetConnectionInterface(IID * pIID);
HRESULT GetConnectionPointContainer(IConnectionPointContainer
** ppCFC);
HRESULT Advise(IUnknown * pUnkSink, DWORD * pdwCookie);
HRESULT Unadvise (DWORD dwCookie);
HRESULT EnumConnections (IEnumConnections**PpEnum);
};
As can be seen from the above interface definition, the IConnectionPoint interface supports five methods. The GetConnectionInterface( ) method names the event set interface which the connection point is willing to call on the event sink to trigger events. Thus, for connection point
16
A, calling the GetConnectionInterface( ) function returns the IID for the instance of the ISomeEvents interface that is provided by the event sink
10
. The GetConnectionPointContainer( ) method allows an event sink or other caller to navigate back to the connection point container that contains the connection point. The Advise( ) method creates an advisory connection with an event sink, and the Unadvise( ) method breaks the connection. The EnumConnections( ) method enumerates the event sinks that are currently connected to the connection point.
FIG. 2
is a flowchart illustrating the steps that are performed by an event sink to establish a connection with an event source and begin the process of firing events. Initially, the event sink obtains an interface pointer for the IConnectionPointContainer interface from the event source to which it seeks to connect Microsoft OLE 2.01 provides the QueryInterface( ) method that returns the interface pointer for a requested interface. The event sink obtains the interface pointer for the IConnectionPointContainer by calling the QueryInterface( ) method on the event source (step
24
in FIG.
2
). For the example shown in
FIG. 1
, the event sink
10
calls QueryInterface( ) on both event source
12
and event source
14
to obtain an interface pointer for the IConnectionPointContainer interface. The event sink
10
then calls the FindConnectionPoint( ) method for each event set that it wishes the event source to source (step
26
in FIG.
2
). For example, in
FIG. 1
, the event sink
10
calls the FindConnectionPoint( ) method twice to locate connection points
16
A and
16
B for event source
12
. Similarly, the even

Affiliated with

Also associated with

Rating

Method and system for providing an event system infrastructure does not yet have a rating. At this time, there are no reviews or comments for this patent.

If you have personal experience with Method and system for providing an event system infrastructure, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and system for providing an event system infrastructure will most certainly appreciate the feedback.

Rate now

Comments { 0 }

Profile ID: LFUS-PAI-O-3073956