//
// Notification Service IDL Description
//

#ifndef _COS_NOTIFY_COMM_IDL_
#define _COS_NOTIFY_COMM_IDL_

#include <CosNotification.idl>
#include <CosEventComm.idl>

/**
 * The CosNotifyComm module defines the interfaces which support Notification
 * Service clients that communicate using Anys, Structured Events, or sequences of
 * Structured Events. In addition, this module defines the interfaces which enable event
 * suppliers to be informed when the types of events being subscribed to by their
 * associated consumers change, and event consumers to be informed whenever there is a
 * change in the types of events being produced by their suppliers (this model is
 * described in detail in section 2.6).
 */
module CosNotifyComm {

  typePrefix CosNotifyComm "omg.org";
 
 	exception InvalidEventType { CosNotification::EventType type; };
  
  /**
   * 
   * The NotifyPublish interface supports an operation which allows a supplier of
   * Notifications to announce, or publish, the names of the types of events it will be
   * supplying, It is intended to be an abstract interface which is inherited by all
   * Notification Service consumer interfaces, and enables suppliers to inform consumers
   * supporting this interface of the types of events they intend to supply.
   * 
   */
 	interface NotifyPublish {

    /**
     *   The offer_change operation takes as input two sequences of event type names: the first
     * specifying those event types which the client of the operation (an event supplier) is
     * informing the target consumer object that it is adding to the list of event types it plans
     * to supply, and the second specifying those event types which the client no longer plans
     * to supply. This operation raises the InvalidEventType exception if one of the event type
     * names supplied in either input parameter is syntactically invalid. In this case, the
     * invalid name is returned in the type field of the exception.
     * Note that each event type name is comprised of two components: the name of the
     * domain in which the event type has meaning, and the name of the actual event type.
     * Also note that either component of a type name may specify a complete domain/event
     * type name, a domain/event type name containing the wildcard * character, or the
     * special event type name %ALL described in section 2.6.5 if the specification
     * 
     */
		  void offer_change (
  				in CosNotification::EventTypeSeq added,
  				in CosNotification::EventTypeSeq removed )
  			raises ( InvalidEventType );

	}; // NotifyPublish

  /**
   * The NotifySubscribe interface supports an operation which allows a consumer of
   * notifications to inform suppliers of notifications of the types of notifications it wishes
   * to receive. It is intended to be an abstract interface which is inherited by all
   * Notification Service supplier interfaces. In essence, its main purpose is to enable
   * notification consumers to inform suppliers of the types of notifications that are of
   * interest to them, ultimately enabling the suppliers to avoid supplying notifications that
   * are not of interest to any consumer.
   * 
   */
 	interface NotifySubscribe {

  /**
   * The subscription_change operation takes as input two sequences of event type names:
   * the first specifying those event types which the associated Consumer wants to add to
   * its subscription list, and the second specifying those event types which the associated
   * consumer wants to remove from its subscription list. This operation raises the
   * InvalidEventType exception if one of the event type names supplied in either input
   * parameter is syntactically invalid. If this case, the invalid name is returned in the type
   * field of the exception.
   * Note that each event type name is comprised of two components: the name of the
   * domain in which the event type has meaning, and the name of the actual event type.
   * Also note that either component of a type name may specify a complete domain/event
   * type name, a domain/event type name containing the wildcard * character, or the
   * special event type name %ALL described in section 2.6.5.
   * 
   */  
		void subscription_change(
				in CosNotification::EventTypeSeq added,
				in CosNotification::EventTypeSeq removed )
			raises ( InvalidEventType );

	 }; // NotifySubscribe
 
  /**
   * The PushConsumer interface supports the functionality required by notification
   * service consumers that receive events as Anys using push-style communication. This
   * interface defines no new attributes or operations directly. Instead, it multiply inherits
   * the PushConsumer interface defined in the CosEventComm module of the OMG
   * Event Service, and the NotifyPublish interface described above. This enables push-style
   * consumers of Any events to also receive offer_change messages from the
   * channel, allowing it to learn about changes to the types of events being offered to the
   * channel by suppliers.
   */
 	interface PushConsumer :
 		NotifyPublish,
 		CosEventComm::PushConsumer {
 	}; // PushConsumer

  /**
   * The PullConsumer interface supports the functionality required by notification service
   * consumers that receive events as Anys using pull-style communication. This interface
   * defines no new attributes or operations directly. Instead, it multiply inherits the
   * PullConsumer interface defined in the CosEventComm module of the OMG Event
   * Service, and the NotifyPublish interface described above. This enables pull-style
   * consumers of Any events to also receive offer_change messages from the channel,
   * allowing it to learn about changes to the types of events being offered to the channel
   * by suppliers.
   */
 	interface PullConsumer :
 		NotifyPublish,
 		CosEventComm::PullConsumer {
 	}; // PullConsumer

  /**
   * The PullSupplier interface supports the functionality required by notification service
   * suppliers that transmit events as Anys using pull-style communication. This interface
   * defines no new attributes or operations directly. Instead, it multiply inherits the
   * PullSupplier interface defined in the CosEventComm module of the OMG Event
   * Service, and the NotifySubscribe interface described above. This enables pull-style
   * suppliers of Any events to also receive subscription_change messages from the
   * channel, allowing it to learn about changes to the types of events being subscribed to
   * by consumers connected to the channel.
   */
 	interface PullSupplier :
 		NotifySubscribe,
 		CosEventComm::PullSupplier {
 	}; // PullSupplier

  /**
   * The PushSupplier interface supports the functionality required by notification service
   * suppliers that transmit events as Anys using push-style communication. This interface
   * defines no new attributes or operations directly. Instead, it multiply inherits the
   * PushSupplier interface defined in the CosEventComm module of the OMG Event
   * Service, and the NotifySubscribe interface described above. This enables push-style
   * suppliers of Any events to also receive subscription_change messages from the
   * channel, allowing it to learn about changes to the types of events being subscribed to
   * by consumers connected to the channel.
   */
 	interface PushSupplier :
 		NotifySubscribe,
 		CosEventComm::PushSupplier {
 	};

  /**
   * The StructuredPushConsumer interface supports an operation which enables
   * consumers to receive Structured Events by the push model. It also defines an operation
   * which can be invoked to disconnect the push consumer from its associated supplier. In
   * addition, the StructuredPushConsumer interface inherits the NotifyPublish interface
   * described above, enabling a notification supplier to inform an instance supporting this
   * interface whenever there is a change to the types of events it intends to produce.
   * Note that an object supporting the StructuredPushConsumer interface can receive all
   * events which were supplied to its associated channel, including events supplied in a
   * form other than a Structured Event. How events supplied to the channel in other forms
   * are internally mapped into a Structured Event for delivery to a
   * StructuredPushConsumer is summarized in Table 2-2.
   */
	 interface StructuredPushConsumer : NotifyPublish {

  /**
   * The push_structured_event operation takes as input a parameter of type
   * StructuredEvent as defined in the CosNotification module. Upon invocation, this
   * parameter will contain an instance of a Structured Event being delivered to the
   * consumer by the supplier to which it is connected. If this operation is invoked upon a
   * StructuredPushConsumer instance that is not currently connected to the supplier of
   * the event, the Disconnected exception will be raised.
   * In reality there are two types of objects that will support the
   * StructuredPushConsumer interface: an object representing an application which
   * receives Structured Events, and a StructuredProxyPushConsumer (defined in the
   * CosNotifyChannelAdmin module) associated with an event channel which receives
   * structured events from a supplier on behalf of the channel. For the first type of object,
   * the implementation of the push_structured_event operation is application specific, and
   * is intended to be supplied by application developers. For the second type of object, the
   * behavior of the operation is tightly linked to the implementation of the event channel.
   * Basically, it is responsible for applying any filters that have been registered by with the
   * StructuredProxyPushConsumer, then either discarding the event or forwarding it to
   * each proxy supplier within the channel depending on whether or not the event passed
   * the filter.
   */
		void push_structured_event(
			in CosNotification::StructuredEvent notification)
			raises(CosEventComm::Disconnected);  
  /**
   * The disconnect_structured_push_consumer operation is invoked to terminate a
   * connection between the target StructuredPushConsumer, and its associated supplier.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target StructuredPushConsumer will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_structured_push_consumer();

	}; // StructuredPushConsumer

  /**
   * The StructuredPullConsumer interface supports the behavior of objects that receive
   * Structured Events using pull-style communication. It defines an operation which can
   * be invoked to disconnect the pull consumer from its associated supplier. In addition,
   * the StructuredPullConsumer interface inherits the NotifyPublish interface described
   * above, enabling a notification supplier to inform an instance supporting this interface
   * whenever there is a change to the types of events it intends to produce.
   * Note that an object supporting the StructuredPullConsumer interface can receive all
   * events which were supplied to its associated channel, including events supplied in a
   * form other than a Structured Event. How events supplied to the channel in other forms
   * are internally mapped into a Structured Event for delivery to a
   * StructuredPullConsumer is summarized in Table 2-2.
   */
	 interface StructuredPullConsumer : NotifyPublish {
  
  /**
   * The disconnect_structured_pull_consumer operation is invoked to terminate a
   * connection between the target StructuredPullConsumer, and its associated supplier.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target StructuredPullConsumer will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_structured_pull_consumer();
	}; // StructuredPullConsumer

  /**
   * The StructuredPullSupplier interface supports operations which enable suppliers to
   * transmit Structured Events by the pull model. It also defines an operation which can be
   * invoked to disconnect the pull supplier from its associated consumer. In addition, the
   * StructuredPullSupplier interface inherits the NotifySubscribe interface described
   * above, enabling a notification consumer to inform an instance supporting this interface
   * whenever there is a change to the types of events it is interested in receiving.
   * Note that an object supporting the StructuredPullSupplier interface can transmit
   * events which can potentially be received by any consumer connected to the channel,
   * including those which consume events in a form other than a Structured Event. How
   * events supplied to the channel in the form of a Structured Event are internally mapped
   * into different forms for delivery to consumers which receive events in a form other
   * than the Structured Event is summarized in Table 2-2.
   */
	 interface StructuredPullSupplier : NotifySubscribe {

  /**
   * The pull_structured_event operation takes no input parameters, and returns a value of
   * type Structured Event as defined in the CosNotification module. Upon invocation,
   * the operation will block until an event is available for transmission, at which time it
   * will return an instance of a Structured Event which contains the event being delivered
   * to its connected consumer. If invoked upon a StructuredPullSupplier that is not
   * currently connected to the consumer of the event, the Disconnected exception will be
   * raised.
   * In reality there are two types of objects that will support the StructuredPullSupplier
   * interface: an object representing an application which transmits Structured Events, and
   * a StructuredProxyPullSupplier (defined in the CosNotifyChannelAdmin module)
   * associated with an event channel which transmits events to a pull style consumer on
   * behalf of the channel. For the first type of object, the implementation of the
   * pull_structured_event operation is application specific, and is intended to be supplied
   * by application developers. The application specific implementation of this operation
   * should construct a structured event, and return it within a StructuredEvent data
   * structure. For the second type of object, the behavior of the operation is tightly linked
   * to the implementation of the event channel. Basically, it is responsible for forwarding
   * a structured event, within an StructuredEvent data structure, as the return value to the
   * consumer it is connected to upon the availability of an event which passes the filter(s)
   * associated with the StructuredProxyPullSupplier. Note that the operation will block
   * until such an event is available to return.
   */
		CosNotification::StructuredEvent pull_structured_event()
			raises(CosEventComm::Disconnected);

  /**
   * The try_pull_structured_event operation takes no input parameters, and returns a value
   * of type StructuredEvent as defined in the CosNotification module. It also returns an
   * output parameter of type boolean which indicates whether or not the return value
   * actually contains an event. Upon invocation, the operation will return an instance of a
   * Structured Event which contains the event being delivered to its connected consumer,
   * if such an event is available for delivery at the time the operation was invoked. If an
   * event is available for delivery and thus returned as the result, the output parameter of
   * the operation will be set to TRUE. If no event is available to return upon invocation,
   * the operation will return immediately with the value of the output parameter set to
   * FALSE. In this case, the return value will not contain a valid event. If invoked upon a
   * StructuredPullSupplier that is not currently connected to the consumer of the event,
   * the Disconnected exception will be raised.
   * In reality there are two types of objects that will support the StructuredPullSupplier
   * interface: an object representing an application which transmits Structured Events, and
   * a StructuredProxyPullSupplier (defined within the CosNotifyChannelAdmin
   * module) associated with an event channel which transmits events to a PullConsumer
   * on behalf of the channel. For the first type of object, the implementation of the
   * try_pull_structured_event operation is application specific, and is intended to be
   * supplied by application developers. If an event is available to be returned upon
   * invocation of this operation, the application specific implementation of this operation
   * should construct a Structured Event, and return it within a StructuredEvent data
   * structure along with setting the value of the output parameter to TRUE. Otherwise, the
   * operation should return immediately after setting the value of the output parameter to
   * FALSE. For the second type of object, the behavior of the operation is tightly linked to
   * the implementation of the event channel. Basically, if an event is available to be
   * returned upon invocation of this operation, it is responsible for forwarding it, within a
   * StructuredEvent data structure, as the return value to the consumer it is connected to,
   * in addition to setting the output parameter to FALSE. If no event is available to return
   * to the consumer upon invocation of this operation, it will immediately return with the
   * output parameter to set to FALSE, and the return value not containing a valid event.
   */
		CosNotification::StructuredEvent try_pull_structured_event(
				out boolean has_event)
			raises(CosEventComm::Disconnected);

  /**
   * The disconnect_structured_pull_supplier operation is invoked to terminate a
   * connection between the target StructuredPullSupplier, and its associated consumer.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target StructuredPullSupplier will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_structured_pull_supplier();

	}; // StructuredPullSupplier

  /**
   * The StructuredPushSupplier interface supports the behavior of objects that transmit
   * Structured Events using push-style communication. It defines an operation which can
   * be invoked to disconnect the push supplier from its associated consumer. In addition,
   * the StructuredPushSupplier interface inherits the NotifySubscribe interface
   * described above, enabling a notification consumer to inform an instance supporting
   * this interface whenever there is a change to the types of events it is interested in
   * receiving.
   * Note that an object supporting the StructuredPushSupplier interface can transmit
   * events which can potentially be received by any consumer connected to the channel,
   * including those which consume events in a form other than a Structured Event. How
   * events supplied to the channel in the form of a Structured Event are internally mapped
   * into different forms for delivery to consumers which receive events in a form other
   * than the Structured Event is summarized in Table 2-2.
   */
	 interface StructuredPushSupplier : NotifySubscribe {

  /**
   * The disconnect_structured_push_supplier operation is invoked to terminate a
   * connection between the target StructuredPushSupplier, and its associated consumer.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target StructuredPushSupplier will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_structured_push_supplier();
	 }; // StructuredPushSupplier

  /**
   * The SequencePushConsumer interface supports an operation which enables
   * consumers to receive sequences Structured Events by the push model. It also defines
   * an operation which can be invoked to disconnect the push consumer from its
   * associated supplier. In addition, the SequencePushConsumer interface inherits the
   * NotifyPublish interface described above, enabling a notification supplier to inform an
   * instance supporting this interface whenever there is a change to the types of events it
   * intends to produce.
   * Note that an object supporting the SequencePushConsumer interface can receive all
   * events which were supplied to its associated channel, including events supplied in a
   * form other than a sequence of Structured Events. How events supplied to the channel
   * in other forms are internally mapped into a sequence of Structured Events for delivery
   * to a SequencePushConsumer is summarized in Table 2-2.
   */
 	interface SequencePushConsumer : NotifyPublish {

  /**
   * The push_structured_events operation takes as input a parameter of type EventBatch
   * as defined in the CosNotification module. This data type is the same as a sequence of
   * Structured Events. Upon invocation, this parameter will contain a sequence of
   * Structured Events being delivered to the consumer by the supplier to which it is
   * connected. If this operation is invoked upon a SequencePushConsumer instance that
   * is not currently connected to the supplier of the event, the Disconnected exception will
   * be raised.
   * Note that the maximum number of events that will be transmitted within a single
   * invocation of this operation, along with the amount of time a supplier of a sequence of
   * Structured Events will accumulate individual events into the sequence before invoking
   * this operation, are controlled by QoS property settings as described in section 2.5.5.
   * In reality there are two types of objects that will support the SequencePushConsumer
   * interface: an object representing an application which receives sequences of Structured
   * Events, and a SequenceProxyPushConsumer (defined in the
   * CosNotifyChannelAdmin module) associated with an event channel which receives
   * sequences of Structured Events from a supplier on behalf of the channel. For the first
   * type of object, the implementation of the push_structured_events operation is
   * application specific, and is intended to be supplied by application developers. For the
   * second type of object, the behavior of the operation is tightly linked to the
   * implementation of the event channel. Basically, it is responsible for applying any
   * filters that have been registered by with the SequenceProxyPushConsumer to each
   * event in each sequence it receives, then either discarding each event or forwarding it to
   * each proxy supplier within the channel depending on whether or not the event passed
   * the filter.
   */
		void push_structured_events(
				in CosNotification::EventBatch notifications)
			raises(CosEventComm::Disconnected);

  /**
   * The disconnect_sequence_push_consumer operation is invoked to terminate a
   * connection between the target SequencePushConsumer, and its associated supplier.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target SequencePushConsumer will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_sequence_push_consumer();

	}; // SequencePushConsumer

  /**
   * The SequencePullConsumer interface supports the behavior of objects that receive
   * sequences of Structured Events using pull-style communication. It defines an operation
   * which can be invoked to disconnect the pull consumer from its associated supplier. In
   * addition, the SequencePullConsumer interface inherits the NotifyPublish interface
   * described above, enabling a notification supplier to inform an instance supporting this
   * interface whenever there is a change to the types of events it intends to produce.
   * Note that an object supporting the SequencePullConsumer interface can receive all
   * events which were supplied to its associated channel, including events supplied in a
   * form other than a sequence of Structured Events. How events supplied to the channel
   * in other forms are internally mapped into a sequence of Structured Events for delivery
   * to a SequencePullConsumer is summarized in Table 2-2.
   */
	 interface SequencePullConsumer : NotifyPublish {
  
  /**
   * The disconnect_sequence_pull_consumer operation is invoked to terminate a
   * connection between the target SequencePullConsumer, and its associated supplier.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target SequencePullConsumer will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_sequence_pull_consumer();
	}; // SequencePullConsumer

  /**
   * The SequencePullSupplier interface supports operations which enable suppliers to
   * transmit sequences of Structured Events by the pull model. It also defines an operation
   * which can be invoked to disconnect the pull supplier from its associated consumer. In
   * addition, the SequencePullSupplier interface inherits the NotifySubscribe interface
   * described above, enabling a notification consumer to inform an instance supporting
   * this interface whenever there is a change to the types of events it is interested in
   * receiving.
   * Note that an object supporting the SequencePullSupplier interface can transmit events
   * which can potentially be received by any consumer connected to the channel, including
   * those which consume events in a form other than a sequence of Structured Events.
   * How events supplied to the channel in the form of a sequence of Structured Events are
   * internally mapped into different forms for delivery to consumers which receive events
   * in a form other than the a sequence of Structured Events is summarized in Table 2-2.
   */
	 interface SequencePullSupplier : NotifySubscribe {

  /**
   * The pull_structured_events operation takes as an input parameter a numeric value, and
   * returns a value of type EventBatch as defined in the CosNotification module. This
   * data type is the same as a sequence of Structured Events. Upon invocation, the
   * operation will block until a sequence of Structured Events is available for transmission,
   * at which time it will return the sequence containing events being delivered to its
   * connected consumer. If invoked upon a SequencePullSupplier that is not currently
   * connected to the consumer of the event, the Disconnected exception will be raised.
   * Note that the maximum length of the sequence returned will never exceed the value of
   * the input parameter. In addition, the amount of time the supplier will accumulate
   * events into the sequence before transmitting it, along with the maximum size of any
   * sequence it will transmit (regardless of the input parameter), are controlled by QoS
   * property settings as described in section 2.5.5.
   * In reality there are two types of objects that will support the SequencePullSupplier
   * interface: an object representing an application which transmits sequences of
   * Structured Events, and a SequenceProxyPullSupplier (defined in the
   * CosNotifyChannelAdmin module) associated with an event channel which transmits
   * events to a pull style consumer on behalf of the channel. For the first type of object,
   * the implementation of the pull_structured_events operation is application specific, and
   * is intended to be supplied by application developers. The application specific
   * implementation of this operation should construct a sequence of Structured Events, and
   * return it within a EventBatch data structure. For the second type of object, the
   * behavior of the operation is tightly linked to the implementation of the event channel.
   * Basically, it is responsible for forwarding a sequence of Structured Events, within an
   * EventBatch data structure, as the return value to the consumer it is connected to upon
   * the availability of events which pass the filter(s) associated with the
   * SequenceProxyPullSupplier. Note that the operation will block until there is a
   * sequence available to return.
   */
		CosNotification::EventBatch pull_structured_events(
				in long max_number )
			raises(CosEventComm::Disconnected);

  /**
   * The try_pull_structured_events operation takes as an input parameter a numeric value,
   * and returns a value of type EventBatch as defined in the CosNotification module.
   * This data type is the same as a sequence of Structured Events. The operation also
   * returns an output parameter of type boolean which indicates whether or not the return
   * value actually contains a sequence of events. Upon invocation, the operation will
   * return a sequence of a Structured Events which contains events being delivered to its
   * connected consumer, if such a sequence is available for delivery at the time the
   * operation was invoked. If an event sequence is available for delivery and thus returned
   * as the result, the output parameter of the operation will be set to TRUE. If no event
   * sequence is available to return upon invocation, the operation will return immediately
   * with the value of the output parameter set to FALSE. In this case, the return value will
   * not contain a valid event sequence. If invoked upon a SequencePullSupplier that is
   * not currently connected to the consumer of the event, the Disconnected exception will
   * be raised.
   * Note that the maximum length of the sequence returned will never exceed the value of
   * the input parameter.
   * In reality there are two types of objects that will support the SequencePullSupplier
   * interface: an object representing an application which transmits sequences of
   * Structured Events, and a SequenceProxyPullSupplier (defined within the
   * CosNotifyChannelAdmin module) associated with an event channel which transmits
   * events to a PullConsumer on behalf of the channel. For the first type of object, the
   * implementation of the try_pull_structured_events operation is application specific, and
   * is intended to be supplied by application developers. If an event sequence is available
   * to be returned upon invocation of this operation, the application specific
   * implementation of this operation should construct an EventBatch instance, and return
   * it along with setting the value of the output parameter to TRUE. Otherwise, the
   * operation should return immediately after setting the value of the output parameter to
   * FALSE. For the second type of object, the behavior of the operation is tightly linked to
   * the implementation of the event channel. Basically, if an event sequence is available to
   * be returned upon invocation of this operation, it is responsible for forwarding it, within
   * an EventBatch data structure, as the return value to the consumer it is connected to, in
   * addition to setting the output parameter to FALSE. If no event sequence is available to
   * return to the consumer upon invocation of this operation, it will immediately return
   * with the output parameter to set to FALSE, and the return value not containing a valid
   * event.
   */
		CosNotification::EventBatch try_pull_structured_events(
				in long max_number,
				out boolean has_event)
			raises(CosEventComm::Disconnected);

  /**
   * The disconnect_sequence_pull_supplier operation is invoked to terminate a connection
   * between the target SequencePullSupplier, and its associated consumer. This operation
   * takes no input parameters and returns no values. The result of this operation is that the
   * target SequencePullSupplier will release all resources it had allocated to support the
   * connection, and dispose its own object reference.
   */
		void disconnect_sequence_pull_supplier();

	}; // SequencePullSupplier

  /**
   * The SequencePushSupplier interface supports the behavior of objects that transmit
   * sequences of Structured Events using push-style communication. It defines an
   * operation which can be invoked to disconnect the push supplier from its associated
   * consumer. In addition, the SequencePushSupplier interface inherits the
   * NotifySubscribe interface described above, enabling a notification consumer to inform
   * an instance supporting this interface whenever there is a change to the types of events
   * it is interested in receiving.
   * Note that an object supporting the SequencePushSupplier interface can transmit
   * events which can potentially be received by any consumer connected to the channel,
   * including those which consume events in a form other than a sequence of Structured
   * Events. How events supplied to the channel in the form of a sequence of Structured
   * Events are internally mapped into different forms for delivery to consumers which
   * receive events in a form other than a sequence of Structured Events is summarized in
   * Table 2-2.
   */
	interface SequencePushSupplier : NotifySubscribe {

  /**
   * The disconnect_sequence_push_supplier operation is invoked to terminate a
   * connection between the target SequencePushSupplier, and its associated consumer.
   * This operation takes no input parameters and returns no values. The result of this
   * operation is that the target SequencePushSupplier will release all resources it had
   * allocated to support the connection, and dispose its own object reference.
   */
		void disconnect_sequence_push_supplier();
	}; // SequencePushSupplier

}; // CosNotifyComm

#endif // _COS_NOTIFY_COMM_IDL_
