//
// Notification Service IDL Description
//

#ifndef _COS_NOTIFY_CHANNEL_ADMIN_IDL_
#define _COS_NOTIFY_CHANNEL_ADMIN_IDL_

#include <CosNotification.idl>
#include <CosNotifyFilter.idl>
#include <CosNotifyComm.idl>
#include <CosEventChannelAdmin.idl>

/**
 * The CosNotifyChannelAdmin module defines the interfaces necessary to create,
 * configure, and administer instances of a Notification Service event channel. It defines
 * the different types of proxy interfaces which support connections from the various
 * types of clients that are supported, the Admin interfaces, the EventChannel interface,
 * and a factory interface for instantiating new channels.
 */
module CosNotifyChannelAdmin {
  
  typePrefix CosNotifyChannelAdmin "omg.org";

  exception ConnectionAlreadyActive {};
  exception ConnectionAlreadyInactive {};
  exception NotConnected {};

  // Forward declarations
  interface ConsumerAdmin;
  interface SupplierAdmin;
  interface EventChannel;
  interface EventChannelFactory;

  enum ProxyType {
    PUSH_ANY,
    PULL_ANY,
    PUSH_STRUCTURED,
    PULL_STRUCTURED,
    PUSH_SEQUENCE,
    PULL_SEQUENCE,
    PUSH_TYPED,
    PULL_TYPED 
  };

  enum ObtainInfoMode {
    ALL_NOW_UPDATES_OFF,
    ALL_NOW_UPDATES_ON,
    NONE_NOW_UPDATES_OFF,
    NONE_NOW_UPDATES_ON
  };

  /**
   * The ProxyConsumer interface is intended to be an abstract interface that is inherited
   * by the different varieties of proxy consumers that can be instantiated within a
   * notification channel. It encapsulates the behaviors common to all Notification Service
   * proxy consumers. In particular, the ProxyConsumer interface inherits the QoSAdmin
   * interface defined within the CosNotification module, and the FilterAdmin interface
   * defined within the CosNotifyFilter module. The former inheritance enables all proxy
   * consumers to administer a list of associated QoS properties, while the latter inheritance
   * enables all proxy consumers to administer a list of associated filter objects. Locally,
   * the ProxyConsumer interface defines a readonly attribute that should be set upon
   * creation of each proxy consumer instance to indicate the specific type of proxy
   * consumer the instance represents, and a readonly attribute which maintains a reference
   * to the SupplierAdmin object that created it. In addition, the ProxyConsumer
   * interface defines an operation that returns the list of event types a given proxy
   * consumer instance is configured to forward, and an operation which can be queried to
   * determine which message level QoS properties can be set on a per-event basis.
   *
   */
  interface ProxyConsumer :
      CosNotification::QoSAdmin,
      CosNotifyFilter::FilterAdmin {

  /**
   * The MyType attribute is a readonly attribute that should be set upon creation of each
   * proxy consumer instance to indicate the specific type of proxy consumer the instance
   * represents.Enumerations are possible to distinguish the type of proxy consumer among
   * the following possibilities: ProxyPushConsumer, ProxyPullConsumer,
   * StructuredProxyPushConsumer, StructuredProxyPullConsumer,
   * SequenceProxyPushConsumer, and SequenceProxyPullConsumer.
   *
   */
  readonly attribute ProxyType MyType;

  /**
   * The MyAdmin attribute is a readonly attribute that should be set upon creation of each
   * proxy consumer instance to maintain the reference of the instance supporting the
   * SupplierAdmin interface that created it.
   */
  readonly attribute SupplierAdmin MyAdmin;

    
  /**
   * The obtain_subscription_types operation returns a list of event type names. This
   * returned list represents the names of event types which consumers connected to the
   * channel are interested in receiving. Consumers express their interest in receiving
   * particular types of events by configuring filters associated with the proxy suppliers to
   * which they are connected to encapsulate constraints which express subscriptions to
   * specific event instances. Such subscriptions could be based on the types and/or
   * contents of events. The proxy suppliers extract the event type information from these
   * subscriptions, and share it with the proxy consumer objects connected to the same
   * channel. Supplier objects can thus obtain this information from the channel by
   * invoking the obtain_subscription_types operation on the proxy consumer object to
   * which they are connected. This information enables suppliers to suppress sending types
   * of events to the channel in which no consumer is currently interested.
   * Note that suppliers can also receive updates to subscription information automatically
   * by enabling the channel to invoke the subscription_change operation they support
   * through inheritence of the CosNotifyComm::NotifySubscribe interface each time a
   * new type of event is added or removed through modification of filters. The
   * obtain_subscription_types operation accepts as input a flag that enables
   * synchronization between the subscription information obtain through these automatic
   * updates, and that obtained through invocation of obtain_subscription_types. The table
   * below summarizes the possible values and associated meanings this flag can take on:
   *
   * @param mode Mode of recuperation
   * @return All subscription types
   */
  CosNotification::EventTypeSeq obtain_subscription_types( in ObtainInfoMode mode );

  /**
   *   The validate_event_qos operation accepts as input a sequence of QoS property name-value
   * pairs which specify a set of QoS settings that a client is interested in setting on a
   * per-event basis. Note that the QoS property settings contained in the optional header
   * fields of a Structured Event may differ from those that are configured on a given proxy
   * object. This operation is essentially a check to see if the target proxy object will honor
   * the setting of a set of QoS properties on a per-event basis to values that may conflict
   * with those set on the proxy itself. If any of the requested settings would not be honored
   * by the target object on a per-event basis, the operation raises the UnsupportedQoS
   * exception. This exception contains as data a sequence of data structures, each of which
   * identifies the name of a QoS property in the input list whose requested setting could
   * not be satisfied, along with an error code and a range of settings for the property which
   * could be satisfied. The meanings of the error codes which might be returned are
   * described in Table 2-5.
   * If all requested QoS property value settings could be satisfied by the target object, the
   * operation returns successfully with an output parameter that contains a sequence of
   * PropertyRange data structures. Each element in this sequence includes the name of a
   * an additional QoS property whose setting is supported by the target object on a per-event
   * basis and which could have been included on the input list while still resulting in
   * a successful return from the operation. Each element also includes the range of values
   * that would have been acceptable for each such property.
   *
   *
   * @param required_qos
   * @param available_qos
   * @exception org.omg.CosNotification.UnsupportedQoS Qos Property was not supported in this implementation
   */
  void validate_event_qos (
     in CosNotification::QoSProperties required_qos,
     out CosNotification::NamedPropertyRangeSeq available_qos)
    raises (CosNotification::UnsupportedQoS);

  }; // ProxyConsumer


  /**
   * The ProxySupplier interface is intended to be an abstract interface that is inherited by
   * the different varieties of proxy suppliers that can be instantiated within a notification
   * channel. It encapsulates the behaviors common to all Notification Service proxy
   * suppliers. In particular, the ProxySupplier interface inherits the QoSAdmin interface
   * defined within the CosNotification module, and the FilterAdmin interface defined
   * within the CosNotifyFilter module. The former inheritance enables all proxy suppliers
   * to administer a list of associated QoS properties, while the latter inheritance enables all
   * proxy suppliers to administer a list of associated filter objects. Locally, the
   * ProxySupplier interface defines a readonly attribute that should be set upon creation
   * of each proxy supplier instance to indicate the specific type of proxy supplier the
   * instance represents, and a readonly attribute which maintains a reference to the
   * ConsumerAdmin object that created it. In addition, the ProxySupplier interface
   * defines attributes that associate with each proxy supplier two mapping filter objects,
   * one for priority and one for lifetime. As described in section 2.3.1, these mapping filter
   * objects enable proxy suppliers to be configured to alter the way they treat events with
   * respect to their priority and lifetime based on the type and contents of each individual
   * event. Lastly, the ProxySupplier interface defines an operation that returns the list of
   * event types that a given proxy supplier could potentially forward to its associated
   * consumer, and an operation which can be queried to determine which message level
   * QoS properties can be set on a per-event basis.
   */
  interface ProxySupplier :
    CosNotification::QoSAdmin,
    CosNotifyFilter::FilterAdmin {

  
  /**
   * The MyType attribute is a readonly attribute that should be set upon creation of each
   * proxy supplier instance to indicate the specific type of proxy supplier the instance
   * represents.Enumerations are possible to distinguish the type of proxy supplier among
   * the following possibilities: ProxyPushSupplier, ProxyPullSupplier,
   * StructuredProxyPushSupplier, StructuredProxyPullSupplier,
   * SequenceProxyPushSupplier, SequenceProxyPullSupplier.
   * 
   * 
   */
  readonly attribute ProxyType MyType;
  
  
  /**
   * The MyAdmin attribute is a readonly attribute that should be set upon creation of each
   * proxy supplier instance to maintain the reference of the instance supporting the
   * ConsumerAdmin interface that created it.
   * 
   * 
   */
  readonly attribute ConsumerAdmin MyAdmin;

  /**
   * The priority_filter attribute contains a reference to an object supporting the
   * MappingFilter interface defined in the CosNotifyFilter module. Such an object
   * encapsulates a list of constraint-value pairs, where each constraint is a boolean
   * expression based on the type and contents of an event, and the value is a possible
   * priority setting for the event. Upon receipt of each event by a proxy supplier object
   * whose priority_filter attribute contains a non-nil reference, the proxy supplier will
   * invoke the appropriate variant of the match operation supported by the mapping filter
   * object. The mapping filter object will proceed to apply its encapsulated constraints to
   * the event, and return the one with the highest associated priority setting which
   * evaluates to TRUE, or else its associated default_value if no constraints evaluate to
   * TRUE. Upon return from the match operation, if the output parameter is TRUE, the
   * proxy supplier treats the event with respect to its priority according to the return value,
   * as opposed to a priority setting contained within the event. If the output parameter is
   * FALSE, the proxy supplier will treat the event with respect to its priority according to
   * the value set for the priority property in the event header if this property is present,
   * otherwise it will use the output parameter returned from the match operation (i.e., the
   * default value of the mapping filter object).
   * 
   */
  attribute CosNotifyFilter::MappingFilter priority_filter;
  
  /**
   * The lifetime_filter attribute contains a reference to an object supporting the
   * MappingFilter interface defined in the CosNotifyFilter module. Such an object
   * encapsulates a list of constraint-value pairs, where each constraint is a boolean
   * expression based on the type and contents of an event, and the value is a possible
   * lifetime setting for the event. Upon receipt of each event by a proxy supplier object
   * whose lifetime_filter attribute contains a non-nil reference, the proxy supplier will
   * invoke the appropriate variant of the match operation supported by the mapping filter
   * object. The mapping filter object will proceed to apply its encapsulated constraints to
   * the event, and return the one with the highest associated lifetime setting which
   * evaluates to TRUE, or else its associated default_value if no constraints evaluate to
   * TRUE. Upon return from the match operation, if the output parameter is TRUE, the
   * proxy supplier treats the event with respect to its lifetime according to the return value,
   * as opposed to a lifetime setting contained within the event. If the output parameter is
   * FALSE, the proxy supplier will treat the event with respect to its lifetime according to
   * the value set for the lifetime property in the event header if this property is present,
   * otherwise it will use the output parameter returned from the match operation (i.e., the
   * default value of the mapping filter object).
   * 
   * @return Lifetime_filter of the proxy
   */
  attribute CosNotifyFilter::MappingFilter lifetime_filter;

  /**
   *  The obtain_offered_types operation returns a list of event type names. Each element of
   * the returned list names a type of event that the target proxy supplier object could
   * potentially forward to its associated consumer. Note that through inheritance, all proxy
   * consumer objects will support the NotifyPublish interface defined in the
   * CosNotifyComm module. This interface supports the offer_change operation, which
   * can be invoked by suppliers each time there is a change to the list of event types they
   * plan to supply to their associated consumer. Thus, this mechanism relies on event
   * suppliers keeping the channel informed of the types of events they plan to supply by
   * invoking the offer_change operation on their associated proxy consumer object.
   * Internally to the channel, the proxy consumers will share the information about event
   * types that will be supplied to the channel with the proxy supplier objects associated
   * with the channel. This enables consumers to discover the types of events that could by
   * supplied to them by the channel by invoking the obtain_offered_types operation on
   * their associated proxy supplier.
   * Note that as mentioned above, consumers can also receive updates to offer information
   * automatically by enabling the channel to invoke the offer_change operation they
   * support through inheritence of the CosNotifyComm::NotifyPublish interface each
   * time a supplier informs the channel of a change to the types of events they plan to
   * supply. The obtain_offered_types operation accepts as input a flag that enables
   * synchronization between the offer information obtain through these automatic updates,
   * and that obtained through invocation of obtain_offered_types. The possible values and
   * associated meanings this flag can take on are similar to those summarized in Table 3-5,
   * except that the information being shared is offer information instead of
   * subscription information.
   * 
   * @param mode Mode of recuperation
   * @return All offer types 
   */
  CosNotification::EventTypeSeq obtain_offered_types(
      in ObtainInfoMode mode );

  /**
   * The validate_event_qos operation accepts as input a sequence of QoS property name-value
   * pairs which specify a set of QoS settings that a client is interested in setting on a
   * per-event basis. Note that the QoS property settings contained in the optional header
   * fields of a Structured Event may differ from those that are configured on a given proxy
   * object. This operation is essentially a check to see if the target proxy object will honor
   * the setting of a set of QoS properties on a per-event basis to values that may conflict
   * with those set on the proxy itself. If any of the requested settings would not be honored
   * by the target object on a per-event basis, the operation raises the UnsupportedQoS
   * exception. This exception contains as data a sequence of data structures, each of which
   * identifies the name of a QoS property in the input list whose requested setting could
   * not be satisfied, along with an error code and a range of settings for the property which
   * could be satisfied. The meanings of the error codes which might be returned are
   * described in Table 2-5.
   * If all requested QoS property value settings could be satisfied by the target object, the
   * operation returns successfully with an output parameter that contains a sequence of
   * PropertyRange data structures. Each element in this sequence includes the name of a
   * an additional QoS property whose setting is supported by the target object on a per-
   * event basis and which could have been included on the input list while still resulting in
   * a successful return from the operation. Each element also includes the range of values
   * that would have been acceptable for each such property.
   * 
   * @param required_qos
   * @param available_qos
   * @exception org.omg.CosNotification.UnsupportedQoS A Qos Properties isn't supported in this implementation
   */
  void validate_event_qos (
    in CosNotification::QoSProperties required_qos,
    out CosNotification::NamedPropertyRangeSeq available_qos)
      raises (CosNotification::UnsupportedQoS);

  }; // ProxySupplier

  /**
   * The ProxyPushConsumer interface supports connections to the channel by suppliers
   * who will push events to the channel as untyped Anys.
   * Through inheritance of the ProxyConsumer interface, the ProxyPushConsumer
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * SupplierAdmin object which created it. In addition, this inheritance implies that a
   * ProxyPushConsumer instance supports an operation which will return the list of
   * event types which consumers connected to the same channel are interested in
   * receiving, and an operation which can return information about the instance’s ability to
   * accept a per-event QoS request.
   * The ProxyPushConsumer interface also inherits from the PushConsumer interface
   * defined within the CosNotifyComm module. This interface supports the push
   * operation which the supplier connected to a ProxyPushConsumer instance will
   * invoke to send an event to the channel in the form of an Any, and the operation
   * required to disconnect the ProxyPushConsumer from its associated supplier. In
   * addition, since the inherited PushConsumer interface inherits the
   * CosNotifyComm::NotifyPublish interface, a supplier connected to an instance
   * supporting the ProxyPushConsumer interface can inform it whenever the list of event
   * types the supplier plans to supply changes.
   * Finally, the ProxyPushConsumer interface defines the operation which can be
   * invoked by a push supplier to establish the connection over which the push supplier
   * will send events to the channel. Note that this can be either a pure event service style,
   * or a notification service style push supplier.
   */
  interface ProxyPushConsumer :
      ProxyConsumer,
      CosNotifyComm::PushConsumer {

    /**
     * The connect_any_push_supplier operation accepts as an input parameter the reference
     * to an object supporting the PushSupplier interface defined within the
     * CosEventComm module of the OMG Event Service. This reference is that of a
     * supplier which plans to push events to the channel with which the target object is
     * associated in the form of untyped Anys. This operation is thus invoked in order to
     * establish a connection between a push-style supplier of events in the form of Anys, and
     * the notification channel. Once established, the supplier can proceed to send events to
     * the channel by invoking the push operation supported by the target
     * ProxyPushConsumer instance. If the target object of this operation is already
     * connected to a push supplier object, the AlreadyConnected exception will be raised.
     * Note that because the PushSupplier interface defined in the CosNotifyComm module
     * inherits from the PushSupplier interface defined in the CosEventComm module, the
     * input parameter to this operation could be either a pure event service style, or a
     * notification service style push supplier. The only difference between the two are that
     * the latter also supports the NotifySubscribe interface, and thus can be the target of
     * subscription_change invocations. The implementation of the ProxyPushConsumer
     * interface should attempt to narrow the input parameter to
     * CosNotifyComm::PushSupplier in order to determine which style of push supplier is
     * connecting to it.
     */
    void connect_any_push_supplier (
      in CosEventComm::PushSupplier push_supplier)
      raises(CosEventChannelAdmin::AlreadyConnected);

  }; // ProxyPushConsumer

  /**
   * The StructuredProxyPushConsumer interface supports connections to the channel by
   * suppliers who will push events to the channel as Structured Events. Through
   * inheritance of the ProxyConsumer interface, the StructuredProxyPushConsumer
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * SupplierAdmin object which created it. In addition, this inheritance implies that a
   * StructuredProxyPushConsumer instance supports an operation which will return the
   * list of event types which consumers connected to the same channel are interested in
   * receiving, and an operation which can return information about the instance’s ability to
   * accept a per-event QoS request.
   * The StructuredProxyPushConsumer interface also inherits from the
   * StructuredPushConsumer interface defined in the CosNotifyComm module. This
   * interface supports the operation which enables a supplier of Structured Events to push
   * them to the StructuredProxyPushConumer, and also the operation which can be
   * invoked to close down the connection from the supplier to the
   * StructuredProxyPushConsumer. In addition, since the StructuredPushConsumer
   * interface inherits from the NotifyPublish interface, a supplier can inform the
   * StructuredProxyPushConsumer to which it is connected whenever the list of event
   * types it plans to supply to the channel changes.
   * Lastly, the StructuredProxyPushConsumer interface defines a method that can be
   * invoked by a push-style supplier of Structured Events in order to establish a connection
   * between the supplier and a notification channel over which the supplier will proceed to
   * send events.
   */
  interface StructuredProxyPushConsumer :
    ProxyConsumer,
    CosNotifyComm::StructuredPushConsumer {

  /**
   * The connect_structured_push_supplier operation accepts as an input parameter the
   * reference to an object supporting the StructuredPushSupplier interface defined
   * within the CosNotifyComm module. This reference is that of a supplier which plans to
   * push events to the channel with which the target object is associated in the form of
   * Structured Events. This operation is thus invoked in order to establish a connection
   * between a push-style supplier of events in the form of Structured Events, and the
   * notification channel. Once established, the supplier can proceed to send events to the
   * channel by invoking the push_structured_event operation supported by the target
   * StructuredProxyPushConsumer instance. If the target object of this operation is
   * already connected to a push supplier object, the AlreadyConnected exception will be
   * raised.
   * @param push_supplier Push supplier to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   */
  void connect_structured_push_supplier (
    in CosNotifyComm::StructuredPushSupplier push_supplier)
    raises(CosEventChannelAdmin::AlreadyConnected);
  }; // StructuredProxyPushConsumer


  /**
   * The SequenceProxyPushConsumer interface supports connections to the channel by
   * suppliers who will push events to the channel as sequences of Structured Events.
   * Through inheritance of the ProxyConsumer interface, the
   * SequenceProxyPushConsumer interface supports administration of various QoS
   * properties, administration of a list of associated filter objects, and a readonly attribute
   * containing the reference of the SupplierAdmin object which created it. In addition,
   * this inheritance implies that a SequenceProxyPushConsumer instance supports an
   * operation which will return the list of event types which consumers connected to the
   * same channel are interested in receiving, and an operation which can return
   * information about the instance’s ability to accept a per-event QoS request.
   * The SequenceProxyPushConsumer interface also inherits from the
   * SequencePushConsumer interface defined in the CosNotifyComm module. This
   * interface supports the operation which enables a supplier of sequences of Structured
   * Events to push them to the SequenceProxyPushConumer, and also the operation
   * which can be invoked to close down the connection from the supplier to the
   * SequenceProxyPushConsumer. In addition, since the SequencePushConsumer
   * interface inherits from the NotifyPublish interface, a supplier can inform the
   * SequenceProxyPushConsumer to which it is connected whenever the list of event
   * types it plans to supply to the channel changes.
   * Lastly, the SequenceProxyPushConsumer interface defines a method that can be
   * invoked by a push-style supplier of sequences of Structured Events in order to
   * establish a connection between the supplier and a notification channel over which the
   * supplier will proceed to send events.
   */
  interface SequenceProxyPushConsumer :
      ProxyConsumer,
      CosNotifyComm::SequencePushConsumer {

  /**
   * The connect_sequence_push_supplier operation accepts as an input parameter the
   * reference to an object supporting the SequencePushSupplier interface defined within
   * the CosNotifyComm module. This reference is that of a supplier which plans to push
   * events to the channel with which the target object is associated in the form of
   * sequences of Structured Events. This operation is thus invoked in order to establish a
   * connection between a push-style supplier of events in the form of sequences of
   * Structured Events, and the notification channel. Once established, the supplier can
   * proceed to send events to the channel by invoking the push_structured_events
   * operation supported by the target SequenceProxyPushConsumer instance. If the
   * target object of this operation is already connected to a push supplier object, the
   * AlreadyConnected exception will be raised.
   * @param push_supplier Push supplier to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   */
  void connect_sequence_push_supplier (
    in CosNotifyComm::SequencePushSupplier push_supplier)
    raises(CosEventChannelAdmin::AlreadyConnected);

  }; // SequenceProxyPushConsumer

  /**
   * The ProxyPullSupplier interface supports connections to the channel by consumers
   * who will pull events from the channel as untyped Anys.
   * Through inheritance of the ProxySupplier interface, the ProxyPullSupplier interface
   * supports administration of various QoS properties, administration of a list of associated
   * filter objects, mapping filters for event priority and lifetime, and a readonly attribute
   * containing the reference of the ConsumerAdmin object which created it. In addition,
   * this inheritance implies that a ProxyPullSupplier instance supports an operation
   * which will return the list of event types which the proxy supplier will potentially by
   * supplying, and an operation which can return information about the instance’s ability
   * to accept a per-event QoS request.
   * The ProxyPullSupplier interface also inherits from the PullSupplier interface defined
   * within the CosNotifyComm module. This interface supports the pull and try_pull
   * operations which the consumer connected to a ProxyPullSupplier instance will invoke
   * to receive an event from the channel in the form of an Any, and the operation required
   * to disconnect the ProxyPullSupplier from its associated consumer. In addition, since
   * the inherited PullSupplier interface inherits the CosNotifyComm::NotifySubscribe
   * interface, an instance supporting the ProxyPullSupplier interface can be informed
   * whenever the list of event types that the consumer connected to it is interested in
   * receiving changes.
   * Finally, the ProxyPullSupplier interface defines the operation which can be invoked
   * by a pull consumer to establish the connection over which the pull consumer will
   * receive events from the channel. Note that this can be either a pure event service style,
   * or a notification service style pull consumer.
   */
  interface ProxyPullSupplier :
    ProxySupplier,
    CosNotifyComm::PullSupplier {

  /**
   * The connect_any_pull_consumer operation accepts as an input parameter the reference
   * to an object supporting the PullConsumer interface defined within the
   * CosEventComm module. This reference is that of a consumer which plans to pull
   * events from the channel with which the target object is associated in the form of
   * untyped Anys. This operation is thus invoked in order to establish a connection
   * between a pull-style consumer of events in the form of Anys, and the notification
   * channel. Once established, the consumer can proceed to receive events from the
   * channel by invoking the pull or try_pull operations supported by the target
   * ProxyPullSupplier instance. If the target object of this operation is already connected
   * to a pull consumer object, the AlreadyConnected exception will be raised.
   * Note that because the PullConsumer interface defined in the CosNotifyComm
   * module inherits from the PullConsumer interface defined in the CosEventComm
   * module, the input parameter to this operation could be either a pure event service style,
   * or a notification service style pull consumer. The only difference between the two are
   * that the latter also supports the NotifyPublish interface, and thus can be the target of
   * offer_change invocations. The implementation of the ProxyPullSupplier interface
   * should attempt to narrow the input parameter to CosNotifyComm::PullConsumer in
   * order to determine which style of pull consumer is connecting to it.
   * @param pull_consumer Push consumer to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   */
  void connect_any_pull_consumer (
    in CosEventComm::PullConsumer pull_consumer)
    raises(CosEventChannelAdmin::AlreadyConnected);

  }; // ProxyPullSupplier

  /**
   * The StructuredProxyPullSupplier interface supports connections to the channel by
   * consumers who will pull events from the channel as Structured Events. Through
   * inheritance of the ProxySupplier interface, the StructuredProxyPullSupplier
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * ConsumerAdmin object which created it. In addition, this inheritance implies that a
   * StructuredProxyPullSupplier instance supports an operation which will return the list
   * of event types which the proxy supplier will potentially by supplying, and an operation
   * which can return information about the instance’s ability to accept a per-event QoS
   * request.
   * The StructuredProxyPullSupplier interface also inherits from the
   * StructuredPullSupplier interface defined in the CosNotifyComm module. This
   * interface supports the operations which enable a consumer of Structured Events to pull
   * them from the StructuredProxyPullSupplier, and also the operation which can be
   * invoked to close down the connection from the consumer to the
   * StructuredProxyPullSupplier. In addition, since the StructuredPullSupplier
   * interface inherits from the NotifySubscribe interface, a StructuredProxyPullSupplier
   * can be notified whenever the list of event types which its associated consumer is
   * interested in receiving changes. This notification occurs via the callback mechanism
   * described in section 2.3.
   * Lastly, the StructuredProxyPullSupplier interface defines a method that can be
   * invoked by a pull-style consumer of Structured Events in order to establish a
   * connection between the consumer and a notification channel over which the consumer
   * will proceed to receive events.
   */
  interface StructuredProxyPullSupplier :
      ProxySupplier,
      CosNotifyComm::StructuredPullSupplier {

  /**
   * The connect_structured_pull_consumer operation accepts as an input parameter the
   * reference to an object supporting the StructuredPullConsumer interface defined
   * within the CosNotifyComm module. This reference is that of a consumer which plans
   * to pull events from the channel to which the target object is associated in the form of
   * Structured Events. This operation is thus invoked in order to establish a connection
   * between a pull-style consumer of events in the form of Structured Events, and the
   * notification channel. Once established, the consumer can proceed to receive events
   * from the channel by invoking the pull_structured_event or try_pull_structured_event
   * operations supported by the target StructuredProxyPullSupplier instance. If the
   * target object of this operation is already connected to a pull consumer object, the
   * AlreadyConnected exception will be raised.
   * @param pull_consumer Push consumer to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   */
  void connect_structured_pull_consumer (
    in CosNotifyComm::StructuredPullConsumer pull_consumer)
    raises(CosEventChannelAdmin::AlreadyConnected);
  }; // StructuredProxyPullSupplier


  /**
   * The SequenceProxyPullSupplier interface supports connections to the channel by
   * consumers who will pull events from the channel as sequences of Structured Events.
   * Through inheritance of the ProxySupplier interface, the SequenceProxyPullSupplier
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * ConsumerAdmin object which created it. In addition, this inheritance implies that a
   * SequenceProxyPullSupplier instance supports an operation which will return the list
   * of event types which the proxy supplier will potentially by supplying, and an operation
   * which can return information about the instance’s ability to accept a per-event QoS
   * request.
   * The SequenceProxyPullSupplier interface also inherits from the
   * SequencePullSupplier interface defined in the CosNotifyComm module. This
   * interface supports the operations which enable a consumer of sequences of Structured
   * Events to pull them from the SequenceProxyPullSupplier, and also the operation
   * which can be invoked to close down the connection from the consumer to the
   * SequenceProxyPullSupplier. In addition, since the SequencePullSupplier interface
   * inherits from the NotifySubscribe interface, a SequenceProxyPullSupplier can be
   * notified whenever the list of event types which its associated consumer is interested in
   * receiving changes. This notification occurs via the callback mechanism described in
   * section 2.3.
   * Lastly, the SequenceProxyPullSupplier interface defines a method that can be
   * invoked by a pull-style consumer of sequences of Structured Events in order to
   * establish a connection between the consumer and a notification channel over which the
   * consumer will proceed to receive events.
   */
  interface SequenceProxyPullSupplier :
    ProxySupplier,
    CosNotifyComm::SequencePullSupplier {

  /**
   * The connect_sequence_pull_consumer operation accepts as an input parameter the
   * reference to an object supporting the SequencePullConsumer interface defined within
   * the CosNotifyComm module. This reference is that of a consumer which plans to pull
   * events from the channel to which the target object is associated in the form of
   * sequences of Structured Events. This operation is thus invoked in order to establish a
   * connection between a pull-style consumer of events in the form of sequences of
   * Structured Events, and the notification channel. Once established, the consumer can
   * proceed to receive events from the channel by invoking the pull_structured_events or
   * try_pull_structured_events operations supported by the target
   * SequenceProxyPullSupplier instance. If the target object of this operation is already
   * connected to a pull consumer object, the AlreadyConnected exception will be raised.
   * @param pull_consumer Push consumer to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   */
  void connect_sequence_pull_consumer (
    in CosNotifyComm::SequencePullConsumer pull_consumer)
    raises(CosEventChannelAdmin::AlreadyConnected);
  }; // SequenceProxyPullSupplier

  /**
   * The ProxyPullConsumer interface supports connections to the channel by suppliers
   * who will make events available for pulling to the channel as untyped Anys.
   * Through inheritance of the ProxyConsumer interface, the ProxyPullConsumer
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * SupplierAdmin object which created it. In addition, this inheritance implies that a
   * ProxyPullConsumer instance supports an operation which will return the list of event
   * types which consumers connected to the same channel are interested in receiving, and
   * an operation which can return information about the instance’s ability to accept a per-event
   * QoS request.
   * The ProxyPullConsumer interface also inherits from the PullConsumer interface
   * defined within the CosEventComm module of the OMG Event Service. This interface
   * supports the operation required to disconnect the ProxyPullConsumer from its
   * associated supplier. In addition, since the inherited PullConsumer interface inherits
   * the CosNotifyComm::NotifyPublish interface, a supplier connected to an instance
   * supporting the ProxyPullConsumer interface can inform it whenever the list of event
   * types the supplier plans to supply changes.
   * Finally, the ProxyPullConsumer interface defines the operation which can be invoked
   * by a pull supplier to establish the connection over which the pull supplier will send
   * events to the channel. Note that this can be either a pure event service style, or a
   * notification service style pull supplier. The ProxyPullConsumer interface also defines
   * a pair of operations which can suspend and resume the connection between a
   * ProxyPullConsumer instance and its associated PullSupplier. During the time such a
   * connection is suspended, the ProxyPullConsumer will not attempt to pull events from
   * its associated PullSupplier.
   */
  interface ProxyPullConsumer :
    ProxyConsumer,
    CosNotifyComm::PullConsumer {

  /**
   * The connect_any_pull_supplier operation accepts as an input parameter the reference
   * to an object supporting the PullSupplier interface defined within the CosEventComm
   * module. This reference is that of a supplier which plans to make events available for
   * pulling to the channel with which the target object is associated in the form of untyped
   * Anys. This operation is thus invoked in order to establish a connection between a pull-style
   * supplier of events in the form of Anys, and the notification channel. Once
   * established, the channel can proceed to receive events from the supplier by invoking
   * the pull or try_pull operations supported by the supplier (whether the channel will
   * invoke pull or try_pull, and the frequency with which it will perform such invocations,
   * is a detail which is specific to the implementation of the channel). If the target object
   * of this operation is already connected to a pull supplier object, the AlreadyConnected
   * exception will be raised. An implementation of the ProxyPullConsumer interface may
   * impose additional requirements on the interface supported by a pull supplier (e.g., it
   * may be designed to invoke some operation other than pull or try_pull in order to
   * receive events). If the pull supplier being connected does not meet those requirements,
   * this operation raises the TypeError exception.
   * Note that because the PullSupplier interface defined in the CosNotifyComm module
   * inherits from the PullSupplier interface defined in the CosEventComm module, the
   * input parameter to this operation could be either a pure event service style, or a
   * notification service style pull supplier. The only difference between the two are that the
   * latter also supports the NotifySubscribe interface, and thus can be the target of
   * subscription_change invocations. The implementation of the ProxyPullConsumer
   * interface should attempt to narrow the input parameter to
   * CosNotifyComm::PullSupplier in order to determine which style of pull supplier is
   * connecting to it.
   * @param pull_supplier Push supplier to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   * @exception CosEventChannelAdmin::TypeError
   */
  void connect_any_pull_supplier (
    in CosEventComm::PullSupplier pull_supplier)
      raises(CosEventChannelAdmin::AlreadyConnected,
          CosEventChannelAdmin::TypeError );

  /**
   * The suspend_connection operation causes the target object supporting the
   * ProxyPullConsumer interface to stop attempting to pull events (using pull or try_pull)
   * from the PullSupplier instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has been previously suspended
   * using this operation and not resumed by invoking resume_connection (described
   * below), the ConnectionAlreadyInactive exception is raised. If no PullSupplier has
   * been connected to the target object when this operation is invoked, the NotConnected
   * exception is raised. Otherwise, the ProxyPullConsumer will not attempt to pull events
   * from the PullSupplier connected to it until resume_connection is subsequently
   * invoked.
   *@exception ConnectionAlreadyInactive Connection is already suspended
   *@exception NotConnected Proxy isn't connected
   */
  void suspend_connection()
      raises(ConnectionAlreadyInactive, NotConnected);

  /**
   * The resume_connection operation causes the target object supporting the
   * ProxyPullConsumer interface to resume attempting to pull events (using pull or
   * try_pull) from the PullSupplier instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has not been previously suspended
   * using this operation by invoking suspend_connection (described above), the
   * ConnectionAlreadyActive exception is raised. If no PullSupplier has been connected
   * to the target object when this operation is invoked, the NotConnected exception is
   * raised. Otherwise, the ProxyPullConsumer will resume attempting to pull events from
   * the PullSupplier connected to it.
   *@exception ConnectionAlreadyActive Connection is already active
   *@exception NotConnected Proxy isn't connected
   */
  void resume_connection()
      raises(ConnectionAlreadyActive, NotConnected);

  }; // ProxyPullConsumer

  /**
   * The StructuredProxyPullConsumer interface supports connections to the channel by
   * suppliers who will make events available for pulling to the channel as Structured
   * Events. Through inheritance of the ProxyConsumer interface, the
   * StructuredProxyPullConsumer interface supports administration of various QoS
   * properties, administration of a list of associated filter objects, and a readonly attribute
   * containing the reference of the SupplierAdmin object which created it. In addition,
   * this inheritance implies that a StructuredProxyPullConsumer instance supports an
   * operation which will return the list of event types which consumers connected to the
   * same channel are interested in receiving, and an operation which can return
   * information about the instance’s ability to accept a per-event QoS request.
   * The StructuredProxyPullConsumer interface also inherits from the
   * StructuredPullConsumer interface defined in the CosNotifyComm module. This
   * interface supports the operation which can be invoked to close down the connection
   * from the supplier to the StructuredProxyPullConsumer. In addition, since the
   * StructuredPullConsumer interface inherits from the NotifyPublish interface, a
   * supplier can inform the StructuredProxyPullConsumer to which it is connected
   * whenever the list of event types it plans to supply to the channel changes.
   * Lastly, the StructuredProxyPullConsumer interface defines a method that can be
   * invoked by a pull-style supplier of Structured Events in order to establish a connection
   * between the supplier and a notification channel over which the supplier will proceed to
   * send events. The StructuredProxyPullConsumer interface also defines a pair of
   * operations which can suspend and resume the connection between a
   * StructuredProxyPullConsumer instance and its associated StructuredPullSupplier.
   * During the time such a connection is suspended, the StructuredProxyPullConsumer
   * will not attempt to pull events from its associated StructuredPullSupplier.
   */
  interface StructuredProxyPullConsumer :
      ProxyConsumer,
      CosNotifyComm::StructuredPullConsumer {

  /**
   * The connect_structured_pull_supplier operation accepts as an input parameter the
   * reference to an object supporting the StructuredPullSupplier interface defined within
   * the CosNotifyComm module. This reference is that of a supplier which plans to make
   * events available for pulling to the channel with which the target object is associated in
   * the form of Structured Events. This operation is thus invoked in order to establish a
   * connection between a pull-style supplier of events in the form of Structured Events,
   * and the notification channel. Once established, the channel can proceed to receive
   * events from the supplier by invoking the pull_structured_event or
   * try_pull_structured_event operations supported by the supplier (whether the channel
   * will invoke pull_structured_event or try_pull_structured_event, and the frequency with
   * which it will perform such invocations, is a detail which is specific to the
   * implementation of the channel). If the target object of this operation is already
   * connected to a pull supplier object, the AlreadyConnected exception will be raised.
   * An implementation of the StructuredProxyPullConsumer interface may impose
   * additional requirements on the interface supported by a pull supplier (e.g., it may be
   * designed to invoke some operation other than pull_structured_event or
   * try_pull_structured_event in order to receive events). If the pull supplier being
   * connected does not meet those requirements, this operation raises the TypeError
   * exception.
   * @param pull_supplier Push supplier to connect to the proxy
   * @exception CosEventChannelAdmin::AlreadyConnected The proxy is already connected
   * @exception CosEventChannelAdmin::TypeError
   */
  void connect_structured_pull_supplier (
      in CosNotifyComm::StructuredPullSupplier pull_supplier)
      raises(CosEventChannelAdmin::AlreadyConnected,
          CosEventChannelAdmin::TypeError );

  /**
   * The suspend_connection operation causes the target object supporting the
   * StructuredProxyPullConsumer interface to stop attempting to pull events (using pull
   * or try_pull) from the StructuredPullSupplier instance connected to it. This operation
   * takes no input parameters and returns no values. If the connection has been previously
   * suspended using this operation and not resumed by invoking resume_connection
   * (described below), the ConnectionAlreadyInactive exception is raised. If no
   * StructuredPullSupplier has been connected to the target object when this operation is
   * invoked, the NotConnected exception is raised. Otherwise, the
   * StructuredProxyPullConsumer will not attempt to pull events from the
   * StructuredPullSupplier connected to it until resume_connection is subsequently
   * invoked.
   * @exception ConnectionAlreadyInactive Connection is already suspended
   * @exception NotConnected Proxy isn't connected
   */
  void suspend_connection()
      raises(ConnectionAlreadyInactive, NotConnected);

  /**
   * The resume_connection operation causes the target object supporting the
   * StructuredProxyPullConsumer interface to resume attempting to pull events (using
   * pull or try_pull) from the StructuredPullSupplier instance connected to it. This
   * operation takes no input parameters and returns no values. If the connection has not
   * been previously suspended using this operation by invoking suspend_connection
   * (described above), the ConnectionAlreadyActive exception is raised. If no
   * StructuredPullSupplier has been connected to the target object when this operation is
   * invoked, the NotConnected exception is raised. Otherwise, the
   * StructuredProxyPullConsumer will resume attempting to pull events from the
   * StrucuturedPullSupplier connected to it.
   * @exception ConnectionAlreadyActive Connection is already active
   * @exception NotConnected Proxy isn't connected
   */
  void resume_connection()
    raises(ConnectionAlreadyActive, NotConnected);

  }; // StructuredProxyPullConsumer

  /**
   * The SequenceProxyPullConsumer interface supports connections to the channel by
   * suppliers who will make events available for pulling to the channel as sequences of
   * Structured Events. Through inheritance of the ProxyConsumer interface, the
   * SequenceProxyPullConsumer interface supports administration of various QoS
   * properties, administration of a list of associated filter objects, and a readonly attribute
   * containing the reference of the SupplierAdmin object which created it. In addition,
   * this inheritance implies that a SequenceProxyPullConsumer instance supports an
   * operation which will return the list of event types which consumers connected to the
   * same channel are interested in receiving, and an operation which can return
   * information about the instance’s ability to accept a per-event QoS request.
   * The SequenceProxyPullConsumer interface also inherits from the
   * SequencePullConsumer interface defined in the CosNotifyComm module. This
   * interface supports the operation which can be invoked to close down the connection
   * from the supplier to the SequenceProxyPullConsumer. In addition, since the
   * SequencePullConsumer interface inherits from the NotifyPublish interface, a
   * supplier can inform the SequenceProxyPullConsumer to which it is connected
   * whenever the list of event types it plans to supply to the channel changes.
   * Lastly, the SequenceProxyPullConsumer interface defines a method that can be
   * invoked by a pull-style supplier of sequences of Structured Events in order to establish
   * a connection between the supplier and a notification channel over which the supplier
   * will proceed to send events. The SequenceProxyPullConsumer interface also defines
   * a pair of operations which can suspend and resume the connection between a
   * SequenceProxyPullConsumer instance and its associated SequencePullSupplier.
   * During the time such a connection is suspended, the SequenceProxyPullConsumer
   * will not attempt to pull events from its associated SequencePullSupplier.
   */
  interface SequenceProxyPullConsumer :
      ProxyConsumer,
      CosNotifyComm::SequencePullConsumer {
    /**
     * The connect_sequence_pull_supplier operation accepts as an input parameter the
     * reference to an object supporting the SequencePullSupplier interface defined within
     * the CosNotifyComm module. This reference is that of a supplier which plans to make
     * events available for pulling to the channel with which the target object is associated in
     * the form of sequences of Structured Events. This operation is thus invoked in order to
     * establish a connection between a pull-style supplier of events in the form of sequences
     * of Structured Events, and the notification channel. Once established, the channel can
     * proceed to receive events from the supplier by invoking the pull_structured_events or
     * try_pull_structured_events operations supported by the supplier (whether the channel
     * will invoke pull_structured_events or try_pull_structured_events, and the frequency
     * with which it will perform such invocations, is a detail which is specific to the
     * implementation of the channel). If the target object of this operation is already
     * connected to a pull supplier object, the AlreadyConnected exception will be raised.
     * An implementation of the SequenceProxyPullConsumer interface may impose
     * additional requirements on the interface supported by a pull supplier (e.g., it may be
     * designed to invoke some operation other than pull_structured_events or
     * try_pull_structured_events in order to receive events). If the pull supplier being
     * connected does not meet those requirements, this operation raises the TypeError
     * exception.
     */
    void connect_sequence_pull_supplier (
      in CosNotifyComm::SequencePullSupplier pull_supplier)
      raises(CosEventChannelAdmin::AlreadyConnected,
            CosEventChannelAdmin::TypeError );
    /**
     * The suspend_connection operation causes the target object supporting the
     * SequenceProxyPullConsumer interface to stop attempting to pull events (using pull
     * or try_pull) from the SequencePullSupplier instance connected to it. This operation
     * takes no input parameters and returns no values. If the connection has been previously
     * suspended using this operation and not resumed by invoking resume_connection
     * (described below), the ConnectionAlreadyInactive exception is raised. If no
     * SequencePullSupplier has been connected to the target object when this operation is
     * invoked, the NotConnected exception is raised. Otherwise, the
     * SequenceProxyPullConsumer will not attempt to pull events from the
     * SeuqencePullSupplier connected to it until resume_connection is subsequently
     * invoked.
     */
    void suspend_connection()
      raises(ConnectionAlreadyInactive, NotConnected);
  
    /**
     * The resume_connection operation causes the target object supporting the
     * SequenceProxyPullConsumer interface to resume attempting to pull events (using
     * pull or try_pull) from the SequencePullSupplier instance connected to it. This
     * operation takes no input parameters and returns no values. If the connection has not
     * been previously suspended using this operation by invoking suspend_connection
     * (described above), the ConnectionAlreadyActive exception is raised. If no
     * SequencePullSupplier has been connected to the target object when this operation is
     * invoked, the NotConnected exception is raised. Otherwise, the
     * SequenceProxyPullConsumer will resume attempting to pull events from the
     * SequencePullSupplier connected to it.
     */
    void resume_connection()
      raises(ConnectionAlreadyActive, NotConnected);

  }; // SequenceProxyPullConsumer


  /**
   * The ProxyPushSupplier interface supports connections to the channel by consumers
   * who will receive events from the channel as untyped Anys.
   * Through inheritance of the ProxySupplier interface, the ProxyPushSupplier interface
   * supports administration of various QoS properties, administration of a list of associated
   * filter objects, mapping filters for event priority and lifetime, and a readonly attribute
   * containing the reference of the ConsumerAdmin object which created it. In addition,
   * this inheritance implies that a ProxyPushSupplier instance supports an operation
   * which will return the list of event types which the proxy supplier will potentially by
   * supplying, and an operation which can return information about the instance’s ability
   * to accept a per-event QoS request.
   * The ProxyPushSupplier interface also inherits from the PushSupplier interface
   * defined within the CosNotifyComm module. This interface supports the operation
   * required to disconnect the ProxyPushSupplier from its associated consumer. In
   * addition, since the inherited PushSupplier interface inherits the
   * CosNotifyComm::NotifySubscribe interface, an instance supporting the
   * ProxyPushSupplier interface can be informed whenever the list of event types that the
   * consumer connected to it is interested in receiving changes.
   * Lastly, the ProxyPushSupplier interface defines the operation which can be invoked
   * by a push consumer to establish the connection over which the push consumer will
   * receive events from the channel. Note that this can be either a pure event service style,
   * or a notification service style push consumer.The ProxyPushSupplier interface also
   * defines a pair of operations which can suspend and resume the connection between a
   * ProxyPushSupplier instance and its associated PushConsumer. During the time such
   * a connection is suspended, the ProxyPushSupplier will accumulate events destined
   * for the consumer but not transmit them until the connection is resumed.
   */
  interface ProxyPushSupplier :
    ProxySupplier,
    CosNotifyComm::PushSupplier {

  /**
   * The connect_any_push_consumer operation accepts as an input parameter the
   * reference to an object supporting the PushConsumer interface defined within the
   * CosEventComm module. This reference is that of a consumer which will receive
   * events from the channel with which the target object is associated in the form of
   * untyped Anys. This operation is thus invoked in order to establish a connection
   * between a push-style consumer of events in the form of Anys, and the notification
   * channel. Once established, the ProxyPushSupplier will proceed to send events
   * destined for the consumer to it by invoking its push operation. If the target object of
   * this operation is already connected to a push consumer object, the AlreadyConnected
   * exception will be raised. An implementation of the ProxyPushSupplier interface may
   * impose additional requirements on the interface supported by a push consumer (e.g., it
   * may be designed to invoke some operation other than push in order to transmit events).
   * If the push consumer being connected does not meet those requirements, this operation
   * raises the TypeError exception.
   * Note that because the PushConsumer interface defined in the CosNotifyComm
   * module inherits from the PushConsumer interface defined in the CosEventComm
   * module, the input parameter to this operation could be either a pure event service style,
   * or a notification service style push consumer. The only difference between the two are
   * that the latter also supports the NotifyPublish interface, and thus can be the target of
   * offer_change invocations. The implementation of the ProxyPushSupplier interface
   * should attempt to narrow the input parameter to CosNotifyComm::PushConsumer in
   * order to determine which style of push consumer is connecting to it.
   */
  void connect_any_push_consumer (
    in CosEventComm::PushConsumer push_consumer)
      raises(CosEventChannelAdmin::AlreadyConnected,
          CosEventChannelAdmin::TypeError );
  /**
   * The suspend_connection operation causes the target object supporting the
   * ProxyPushSupplier interface to stop sending events to the PushConsumer instance
   * connected to it. This operation takes no input parameters and returns no values. If the
   * connection has been previously suspended using this operation and not resumed by
   * invoking resume_connection (described below), the ConnectionAlreadyInactive
   * exception is raised. If no PushConsumer has been connected to the target object when
   * this operation is invoked, the NotConnected exception is raised. Otherwise, the
   * ProxyPushSupplier will not forward events to the PushConsumer connected to it
   * until resume_connection is subsequently invoked. During this time, the
   * ProxyPushSupplier will continue to queue events destined for the PushConsumer,
   * although events that time out prior to resumption of the connection will be discarded.
   * Upon resumption of the connection, all queued events will be forwarded to the
   * PushConsumer.
   */
  void suspend_connection()
    raises(ConnectionAlreadyInactive, NotConnected);

  /**
   * The resume_connection operation causes the target object supporting the
   * ProxyPushSupplier interface to resume sending events to the PushConsumer
   * instance connected to it. This operation takes no input parameters and returns no
   * values. If the connection has not been previously suspended using this operation by
   * invoking suspend_connection (described above), the ConnectionAlreadyActive
   * exception is raised. If no PushConsumer has been connected to the target object when
   * this operation is invoked, the NotConnected exception is raised. Otherwise, the
   * ProxyPushSupplier will resume forwarding events to the PushConsumer connected
   * to it, including those which have been queued during the time the connection was
   * suspended, and have not yet timed out.
   */
  void resume_connection()
    raises(ConnectionAlreadyActive, NotConnected);

  }; // ProxyPushSupplier

  /**
   * The StructuredProxyPushSupplier interface supports connections to the channel by
   * consumers who will receive events from the channel as Structured Events. Through
   * inheritance of the ProxySupplier interface, the StructuredProxyPushSupplier
   * interface supports administration of various QoS properties, administration of a list of
   * associated filter objects, and a readonly attribute containing the reference of the
   * ConsumerAdmin object which created it. In addition, this inheritance implies that a
   * StructuredProxyPushSupplier instance supports an operation which will return the
   * list of event types which the proxy supplier will potentially by supplying, and an
   * operation which can return information about the instance’s ability to accept a per-event
   * QoS request.
   * The StructuredProxyPushSupplier interface also inherits from the
   * StructuredPushSupplier interface defined in the CosNotifyComm module. This
   * interface supports the operation which can be invoked to close down the connection
   * from the consumer to the StructuredProxyPushSupplier. In addition, since the
   * StructuredPushSupplier interface inherits from the NotifySubscribe interface, a
   * StructuredProxyPushSupplier can be notified whenever the list of event types which
   * its associated consumer is interested in receiving changes. This notification occurs via
   * the callback mechanism described in section 2.3.
   * Lastly, the StructuredProxyPushSupplier interface defines the operation which can
   * be invoked by a push consumer to establish the connection over which the push
   * consumer will receive events from the channel. The StructuredProxyPushSupplier
   * interface also defines a pair of operations which can suspend and resume the
   * connection between a StructuredProxyPushSupplier instance and its associated
   * StructuredPushConsumer. During the time such a connection is suspended, the
   * StructuredProxyPushSupplier will accumulate events destined for the consumer but
   * not transmit them until the connection is resumed.
   */
  interface StructuredProxyPushSupplier :
    ProxySupplier,
    CosNotifyComm::StructuredPushSupplier {

  /**
   * The connect_structured_push_consumer operation accepts as an input parameter the
   * reference to an object supporting the StructuredPushConsumer interface defined
   * within the CosNotifyComm module. This reference is that of a consumer which will
   * receive events from the channel with which the target object is associated in the form
   * of Structured Events. This operation is thus invoked in order to establish a connection
   * between a push-style consumer of events in the form of Structured Events, and the
   * notification channel. Once established, the StructuredProxyPushSupplier will
   * proceed to send events destined for the consumer to it by invoking its
   * push_structured_event operation. If the target object of this operation is already
   * connected to a push consumer object, the AlreadyConnected exception will be raised.
   * An implementation of the StructuredProxyPushSupplier interface may impose
   * additional requirements on the interface supported by a push consumer (e.g., it may be
   * designed to invoke some operation other than push_structured_event in order to
   * transmit events). If the push consumer being connected does not meet those
   * requirements, this operation raises the TypeError exception.
   */
  void connect_structured_push_consumer (
    in CosNotifyComm::StructuredPushConsumer push_consumer)
    raises(CosEventChannelAdmin::AlreadyConnected,
          CosEventChannelAdmin::TypeError );

  /**
   * The suspend_connection operation causes the target object supporting the
   * StructuredProxyPushSupplier interface to stop sending events to the
   * StructuredPushConsumer instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has been previously suspended
   * using this operation and not resumed by invoking resume_connection (described
   * below), the ConnectionAlreadyInactive exception is raised. If no
   * StructuredPushConsumer has been connected to the target object when this
   * operation is invoked, the NotConnected exception is raised. Otherwise, the
   * StructuredProxyPushSupplier will not forward events to the
   * StructuredPushConsumer connected to it until resume_connection is subsequently
   * invoked. During this time, the StructuredProxyPushSupplier will continue to queue
   * events destined for the StructuredPushConsumer, although events that time out prior
   * to resumption of the connection will be discarded. Upon resumption of the connection,
   * all queued events will be forwarded to the StructuredPushConsumer.
   */
  void suspend_connection()
    raises(ConnectionAlreadyInactive, NotConnected);
  
  /**
   * The resume_connection operation causes the target object supporting the
   * StructuredProxyPushSupplier interface to resume sending events to the
   * StructuredPushConsumer instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has not been previously suspended
   * using this operation by invoking suspend_connection (described above), the
   * ConnectionAlreadyActive exception is raised. If no StructuredPushConsumer has
   * been connected to the target object when this operation is invoked, the NotConnected
   * exception is raised. Otherwise, the StructuredProxyPushSupplier will resume
   * forwarding events to the StructuredPushConsumer connected to it, including those
   * which have been queued during the time the connection was suspended, and have not
   * yet timed out.
   */
  void resume_connection()
    raises(ConnectionAlreadyActive, NotConnected);

  }; // StructuredProxyPushSupplier

  /**
   * The SequenceProxyPushSupplier interface supports connections to the channel by
   * consumers who will receive events from the channel as sequences of Structured
   * Events. Through inheritance of the ProxySupplier interface, the
   * SequenceProxyPushSupplier interface supports administration of various QoS
   * properties, administration of a list of associated filter objects, and a readonly attribute
   * containing the reference of the ConsumerAdmin object which created it. In addition,
   * this inheritance implies that a SequenceProxyPushSupplier instance supports an
  * operation which will return the list of event types which the proxy supplier will
  * potentially by supplying, and an operation which can return information about the
  * instance’s ability to accept a per-event QoS request.
  * The SequenceProxyPushSupplier interface also inherits from the
  * SequencePushSupplier interface defined in the CosNotifyComm module. This
  * interface supports the operation which can be invoked to close down the connection
  * from the consumer to the SequenceProxyPushSupplier. In addition, since the
  * SequencePushSupplier interface inherits from the NotifySubscribe interface, a
  * SequenceProxyPushSupplier can be notified whenever the list of event types which
  * its associated consumer is interested in receiving changes. This notification occurs via
  * the callback mechanism described in section 2.3.
  * Lastly, the SequenceProxyPushSupplier interface defines the operation which can be
  * invoked by a push consumer to establish the connection over which the push consumer
  * will receive events from the channel. The SequenceProxyPushSupplier interface also
  * defines a pair of operations which can suspend and resume the connection between a
  * SequenceProxyPushSupplier instance and its associated SequencePushConsumer.
  * During the time such a connection is suspended, the SequenceProxyPushSupplier
  * will accumulate events destined for the consumer but not transmit them until the
  * connection is resumed.
  */
  interface SequenceProxyPushSupplier :
      ProxySupplier,
      CosNotifyComm::SequencePushSupplier {

  /**
   * The connect_sequence_push_consumer operation accepts as an input parameter the
   * reference to an object supporting the SequencePushConsumer interface defined
   * within the CosNotifyComm module. This reference is that of a consumer which will
   * receive events from the channel with which the target object is associated in the form
   * of sequences of Structured Events. This operation is thus invoked in order to establish
   * a connection between a push-style consumer of events in the form of sequences of
   * Structured Events, and the notification channel. Once established, the
   * SequenceProxyPushSupplier will proceed to send events destined for the consumer
   * to it by invoking its push_structured_events operation. If the target object of this
   * operation is already connected to a push consumer object, the AlreadyConnected
   * exception will be raised. An implementation of the SequenceProxyPushSupplier
   * interface may impose additional requirements on the interface supported by a push
   * consumer (e.g., it may be designed to invoke some operation other than
   * push_structured_events in order to transmit events). If the push consumer being
   * connected does not meet those requirements, this operation raises the TypeError
   * exception.
   */
  void connect_sequence_push_consumer (
    in CosNotifyComm::SequencePushConsumer push_consumer)
    raises(CosEventChannelAdmin::AlreadyConnected,
        CosEventChannelAdmin::TypeError );

  /**
   * The suspend_connection operation causes the target object supporting the
   * SequenceProxyPushSupplier interface to stop sending events to the
   * SequencePushConsumer instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has been previously suspended
   * using this operation and not resumed by invoking resume_connection (described
   * below), the ConnectionAlreadyInactive exception is raised. If no
   * SequencePushConsumer has been connected to the target object when this operation
   * is invoked, the NotConnected exception is raised. Otherwise, the
   * SequenceProxyPushSupplier will not forward events to the
   * SequencePushConsumer connected to it until resume_connection is subsequently
   * invoked. During this time, the SequenceProxyPushSupplier will continue to queue
   * events destined for the SequencePushConsumer, although events that time out prior
   * to resumption of the connection will be discarded. Upon resumption of the connection,
   * all queued events will be forwarded to the SequencePushConsumer.
   */
  void suspend_connection()
    raises(ConnectionAlreadyInactive, NotConnected);

  /**
   * The resume_connection operation causes the target object supporting the
   * SequenceProxyPushSupplier interface to resume sending events to the
   * SequencePushConsumer instance connected to it. This operation takes no input
   * parameters and returns no values. If the connection has not been previously suspended
   * using this operation by invoking suspend_connection (described above), the
   * ConnectionAlreadyActive exception is raised. If no SequencePushConsumer has
   * been connected to the target object when this operation is invoked, the NotConnected
   * exception is raised. Otherwise, the SequenceProxyPushSupplier will resume
   * forwarding events to the SequencePushConsumer connected to it, including those
   * which have been queued during the time the connection was suspended, and have not
   * yet timed out.
   */
  void resume_connection()
    raises(ConnectionAlreadyActive, NotConnected);

  }; // SequenceProxyPushSupplier

  typedef long ProxyID;
  typedef sequence <ProxyID> ProxyIDSeq;

  enum ClientType {
    ANY_EVENT,
    STRUCTURED_EVENT,
    SEQUENCE_EVENT
  };

  enum InterFilterGroupOperator { AND_OP, OR_OP };

  typedef long AdminID;
  typedef sequence<AdminID> AdminIDSeq;

  exception AdminNotFound {};
  exception ProxyNotFound {};

  struct AdminLimit {
    CosNotification::PropertyName name;
    CosNotification::PropertyValue value;
  };

  exception AdminLimitExceeded { AdminLimit admin_property_err; };
  
  /**
   * The ConsumerAdmin interface defines the behavior supported by objects which
   * create and manage lists of proxy supplier objects within a Notification Service event
   * channel. Recall that a Notification Service event channel can have any number of
   * ConsumerAdmin instances associated with it. Each such instance is responsible for
   * creating and managing a list of proxy supplier objects that share a common set of QoS
   * property settings, and a common set of filter objects. This feature enables clients to
   * conveniently group proxy supplier objects within a channel into groupings that each
   * support a set of consumers with a common set of QoS requirements and event
   * subscriptions.
   * The ConsumerAdmin interface inherits the QoSAdmin interface defined within the
   * CosNotification module, enabling each ConsumerAdmin instance to manage a set of
   * QoS property settings. These QoS property settings are assigned as the default QoS
   * property settings for any proxy supplier object created by a ConsumerAdmin
   * instance. In addition, the ConsumerAdmin interface inherits from the FilterAdmin
   * interface defined within the CosNotifyFilter module, enabling each ConsumerAdmin
   * instance to maintain a list of filter objects. These filter objects encapsulate
   * subscriptions that will apply to all proxy supplier objects that have been created by a
   * given ConsumerAdmin instance. In order to enable optimizing the notification of a
   * group of proxy supplier objects that have been created by the same ConsumerAdmin
   * instance of changes to these shared filter objects, the ConsumerAdmin interface also
   * inherits from the NotifySubscribe interface defined in the CosNotifyComm module.
   * This inheritance enables a ConsumerAdmin instance to be registered as the callback
   * object for notification of subscription changes made upon filter objects.
   * The ConsumerAdmin interface defined in the CosNotifyChannelAdmin module also
   * inherits from the ConsumerAdmin interface defined in the CosEventChannelAdmin
   * module. This inheritance enables clients to use the ConsumerAdmin interface defined
   * in the CosNotifyChannelAdmin module to create pure OMG Event Service style
   * proxy supplier objects. Proxy supplier objects created in this manner may not support
   * configuration of QoS properties, and may not have associated filter objects. In
   * addition, proxy supplier objects created through the inherited ConsumerAdmin
   * interface will not have unique identifiers associated with them, whereas proxy supplier
   * objects created by invoking the operations supported by the ConsumerAdmin
   * interface defined in the CosNotifyChannelAdmin module will.
   * Locally, the ConsumerAdmin interface supports a readonly attribute which maintains
   * a reference to the EventChannel instance that created a given ConsumerAdmin
   * instance. The ConsumerAdmin interface also supports a readonly attribute which
   * contains a numeric identifier which will be assigned to an instance supporting this
   * interface by its associated Notification Service event channel upon creation of the
   * ConsumerAdmin instance. This identifier will be unique among all ConsumerAdmin
   * instances created by a given channel.
   * As described above, due to inheritance from the FilterAdmin interface, a
   * ConsumerAdmin can maintain a list of filter objects that will be applied to all proxy
   * suppliers it creates. Also recall that each proxy supplier may itself support a list of
   * filter objects that apply only it. When combining multiple filter objects within each of
   * these two lists of filter objects that may be associated with a given proxy supplier, OR
   * semantics are applied. However when combining these two lists during the evaluation
   * of a given event, either AND or OR semantics may be applied. The choice is
   * determined by an input flag upon creation of the ConsumerAdmin, and the operator
   * that will be used for this purpose by a given ConsumerAdmin is maintained in a
   * readonly attribute.
   * The ConsumerAdmin interface also supports attributes which maintain references to
   * priority and lifetime mapping filter objects. These mapping filter objects will be
   * applied to all proxy supplier objects created by a given ConsumerAdmin instance.
   * Each ConsumerAdmin instance assigns a unique numeric identifier to each proxy
   * supplier object it maintains. The ConsumerAdmin interface supports attributes which
   * maintain the list of these unique identifiers associated with the proxy pull and the
   * proxy push suppliers created by a given ConsumerAdmin instance. The
   * ConsumerAdmin interface also supports an operation which, given the unique
   * identifier of a proxy supplier a given ConsumerAdmin instance has created as input,
   * will return the object reference of that proxy supplier object. Additionally, the
   * ConsumerAdmin interface supports operations which can create the various styles of
   * proxy supplier objects supported by the Notification Service event channel. Finally,
   * because clients of a given Notification Service event channel can create any number of
   * ConsumerAdmin instances, a destroy operation is provided by this interface so that
   * clients can clean up instances that are no longer needed.
   *
   */
  interface ConsumerAdmin :
      CosNotification::QoSAdmin,
      CosNotifyComm::NotifySubscribe,
      CosNotifyFilter::FilterAdmin,
      CosEventChannelAdmin::ConsumerAdmin {

    /**
     * The MyID attribute is a readonly attribute which maintains the unique identifier of the
     * target ConsumerAdmin instance which is assigned to it upon creation by the
     * Notification Service event channel.
     * 
     */
    readonly attribute AdminID MyID;
  
    /**
     * The MyChannel attribute is a readonly attribute which maintains the object reference
     * of the Notification Service event channel that created a given ConsumerAdmin
     * instance.
     * 
     */
    readonly attribute EventChannel MyChannel;

    /**
     * The MyOperator attribute is a readonly attribute which maintains the information
     * regarding whether AND or OR semantics will be used during the evaluation of a given
     * event against a set of filter objects, when combining the filter objects associated with
     * the target ConsumerAdmin and those defined locally on a given proxy supplier.
     */
    readonly attribute InterFilterGroupOperator MyOperator;

    /**
     * The priority_filter attribute maintains a reference to a mapping filter object which
     * affects the way in which each proxy supplier object created by the target
     * ConsumerAdmin instance treats each event it receives with respect to priority.
     * Note that each proxy supplier object also has an associated attribute which maintains a
     * reference to a mapping filter object for the priority property. This local mapping filter
     * object is only used by the proxy supplier in the event that the priority_filter attribute of
     * the ConsumerAdmin instance which created it is set to OBJECT_NIL. Otherwise, the
     * mapping filter object referred to by the priority_filter attribute of the
     * ConsumerAdmin is used instead of the mapping filter object referred to by the
     * priority_filter attribute defined locally to the proxy supplier object.
     */
    attribute CosNotifyFilter::MappingFilter priority_filter;
  
    /**
     * The lifetime_filter attribute maintains a reference to a mapping filter object which
     * affects the way in which each proxy supplier object created by the target
     * ConsumerAdmin instance treats each event it receives with respect to lifetime.
     * Note that each proxy supplier object also has an associated attribute which maintains a
     * reference to a mapping filter object for the lifetime property. This local mapping filter
     * object is only used by the proxy supplier in the event that the lifetime_filter attribute of
     * the ConsumerAdmin instance which created it is set to OBJECT_NIL. Otherwise, the
     * mapping filter object referred to by the lifetime_filter attribute of the
     * ConsumerAdmin is used instead of the mapping filter object referred to by the
     * lifetime_filter attribute defined locally to the proxy supplier object.
     */ 
    attribute CosNotifyFilter::MappingFilter lifetime_filter;

    /**
     * The pull_suppliers attribute is a readonly attribute which contains the list of unique
     * identifiers which have been assigned by a ConsumerAdmin instance to each pull-style
     * proxy supplier object it has created.
     */
    readonly attribute ProxyIDSeq pull_suppliers;
    
    /**
     * The push_suppliers attribute is a readonly attribute which contains the list of unique
     *  identifiers which have been assigned by a ConsumerAdmin instance to each push-style
     * proxy supplier object it has created. 
     */ 
    readonly attribute ProxyIDSeq push_suppliers;

    /**
     * The get_proxy_supplier operation accepts as an input parameter the numeric unique
     * identifier associated with one of the proxy supplier objects which has been created by
     * the target ConsumerAdmin instance. If the input parameter does correspond to the
     * unique identifier of a proxy supplier object that has been created by the target
     * ConsumerAdmin instance, that proxy supplier object’s reference is returned as the
     * result of the operation. Otherwise, the ProxyNotFound exception is raised.
     */ 
    ProxySupplier get_proxy_supplier (
        in ProxyID proxy_id )
      raises ( ProxyNotFound );

    /**
     * The obtain_notification_pull_supplier operation can create instances of the various
     * types of pull-style proxy supplier objects defined within the CosNotifyChannelAdmin
     * module. Recall that three varieties of pull-style proxy supplier objects are defined
     * within this module: instances of the ProxyPullSupplier interface support connections
     * to pull consumers which receive events as Anys, instances of the
     * StructuredProxyPullSupplier interface support connections to pull consumers which
     * receive events as Structured Events, and instances of the SequenceProxyPullSupplier
     * interface support connections to pull consumers which receive events as sequences of
     * Structured Events.
     * The obtain_notification_pull_supplier operation thus accepts as an input parameter a
     * flag which indicates which style of pull-style proxy supplier instance should be
     * created. If the number of consumers currently connected to the channel with which the
     * target ConsumerAdmin object is associated exceeds the value of the MaxConsumers
     * administrative property, the AdminLimitExceeded exception is raised. Otherwise, the
     * target ConsumerAdmin creates the new pull-style proxy supplier instance and assigns
     * a numeric identifier to it that is unique among all proxy suppliers it has created. The
     * unique identifier is returned as the output parameter of the operation, and the reference
     * to the new proxy supplier instance is returned as the operation result.
     */
    ProxySupplier obtain_notification_pull_supplier (
        in ClientType ctype,
        out ProxyID proxy_id)
      raises ( AdminLimitExceeded );

    /**
     * The obtain_notification_push_supplier operation can create instances of the various
     * types of push-style proxy supplier objects defined within the
     * CosNotifyChannelAdmin module. Recall that three varieties of push-style proxy
     * supplier objects are defined within this module: instances of the ProxyPushSupplier
     * interface support connections to push consumers which receive events as Anys,
     * instances of the StructuredProxyPushSupplier interface support connections to push
     * consumers which receive events as Structured Events, and instances of the
     * SequenceProxyPushSupplier interface support connections to push consumers which
     * receive events as sequences of Structured Events.
     * The obtain_notification_push_supplier operation thus accepts as an input parameter a
     * flag which indicates which style of push-style proxy supplier instance should be
     * created. If the number of consumers currently connected to the channel with which the
     * target ConsumerAdmin object is associated exceeds the value of the MaxConsumers
     * administrative property, the AdminLimitExceeded exception is raised. Otherwise, the
     * target ConsumerAdmin creates the new push-style proxy supplier instance and
     * assigns a numeric identifier to it that is unique among all proxy suppliers it has
     * created. The unique identifier is returned as the output parameter of the operation, and
     * the reference to the new proxy supplier instance is returned as the operation result.
     */
    ProxySupplier obtain_notification_push_supplier (
        in ClientType ctype,
        out ProxyID proxy_id)
      raises ( AdminLimitExceeded );

  
    /**
     * The destroy operation can be invoked to destroy the target ConsumerAdmin instance,
     * freeing all resources consumed by the instance. Note that destroy can be invoked on a
     * ConsumerAdmin instance that is current managing proxy supplier objects that support
     * open connections to consumers. In this case, the effect of invoking destroy on the
     * ConsumerAdmin is that the operation will disconnect each of the proxy supplier
     * objects being managed by the target ConsumerAdmin from their consumers, and
     * destroy each of these proxy suppliers. Ultimately, the ConsumerAdmin instance itself
     * will be destroyed.
     */
    void destroy();

  }; // ConsumerAdmin


  /**
   * The SupplierAdmin interface defines the behavior supported by objects which create
   * and manage lists of proxy consumer objects within a Notification Service event
   * channel. Recall that a Notification Service event channel can have any number of
   * SupplierAdmin instances associated with it. Each such instance is responsible for
   * creating and managing a list of proxy consumer objects that share a common set of
   * QoS property settings, and a common set of filter objects. This feature enables clients
   * to conveniently group proxy consumer objects within a channel into groupings that
   * each support a set of suppliers with a common set of QoS requirements, and that make
   * common event forwarding decisions driven by the association of a common set of filter
   * objects.
   * The SupplierAdmin interface inherits the QoSAdmin interface defined within the
   * CosNotification module, enabling each SupplierAdmin instance to manage a set of
   * QoS property settings. These QoS property settings are assigned as the default QoS
   * property settings for any proxy consumer object created by a SupplierAdmin instance.
   * In addition, the SupplierAdmin interface inherits from the FilterAdmin interface
   * defined within the CosNotifyFilter module, enabling each SupplierAdmin instance to
   * maintain a list of filter objects. These filter objects encapsulate subscriptions that will
   * apply to all proxy consumer objects that have been created by a given SupplierAdmin
   * instance. In order to enable optimizing the notification of a group of proxy consumer
   * objects that have been created by the same SupplierAdmin instance of changes to the
   * types of events being offered by suppliers, the SupplierAdmin interface also inherits
   * from the NotifyPublish interface defined in the CosNotifyComm module. This
   * inheritance enables a SupplierAdmin instance to be the target of an offer_change
   * request made by a supplier object, and for the change in event types being offered to
   * be shared by all proxy consumer objects which were created by the target
   * SupplierAdmin.
   * The SupplierAdmin interface defined in the CosNotifyChannelAdmin module also
   * inherits from the SupplierAdmin interface defined in the CosEventChannelAdmin
   * module. This inheritance enables clients to use the SupplierAdmin interface defined
   * in the CosNotifyChannelAdmin module to create pure OMG Event Service style
   * proxy consumer objects. Proxy consumer objects created in this manner may not
   * support configuration of QoS properties, and may not have associated filter objects. In
   * addition, proxy consumer objects created through the inherited SupplierAdmin
   * interface will not have unique identifiers associated with them, whereas proxy
   * consumer objects created by invoking the operations supported by the SupplierAdmin
   * interface defined in the CosNotifyChannelAdmin module will.
   * Locally, the SupplierAdmin interface supports a readonly attribute which maintains a
   * reference to the EventChannel instance that created a given SupplierAdmin instance.
   * The SupplierAdmin interface also supports a readonly attribute which contains a
   * numeric identifier which will be assigned to an instance supporting this interface by its
   * associated Notification Service event channel upon creation of the SupplierAdmin
   * instance. This identifier will be unique among all SupplierAdmin instances created by
   * a given channel.
   * As described above, due to inheritance from the FilterAdmin interface, a
   * SupplierAdmin can maintain a list of filter objects that will be applied to all proxy
   * consumers it creates. Also recall that each proxy consumer may itself support a list of
   * filter objects that apply only it. When combining multiple filter objects within each of
   * these two lists of filter objects that may be associated with a given proxy consumer,
   * OR semantics are applied. However when combining these two lists during the
   * evaluation of a given event, either AND or OR semantics may be applied. The choice
   * is determined by an input flag upon creation of the SupplierAdmin, and the operator
   * that will be used for this purpose by a given SupplierAdmin is maintained in a
   * readonly attribute.
   * Each SupplierAdmin instance assigns a unique numeric identifier to each proxy
   * consumer object it maintains. The SupplierAdmin interface supports attributes which
   * maintain the list of these unique identifiers associated with the proxy pull and the
   * proxy push consumers created by a given SupplierAdmin instance. The
   * SupplierAdmin interface also supports an operation which, given the unique identifier
   * of a proxy consumer a given SupplierAdmin instance has created as input, will return
   * the object reference of that proxy consumer object. Additionally, the SupplierAdmin
   * interface supports operations which can create the various styles of proxy consumer
   * objects supported by the Notification Service event channel. Finally, because clients of
   * a given Notification Service event channel can create any number of SupplierAdmin
   * instances, a destroy operation is provided by this interface so that clients can clean up
   * instances that are no longer needed.
   */
  interface SupplierAdmin :
    CosNotification::QoSAdmin,
    CosNotifyComm::NotifyPublish,
    CosNotifyFilter::FilterAdmin,
    CosEventChannelAdmin::SupplierAdmin {
   
    /**
     * The MyID attribute is a readonly attribute which maintains the unique identifier of the
     * target SupplierAdmin instance which is assigned to it upon creation by the
     * Notification Service event channel.
     */
    readonly attribute AdminID MyID;
    
    /**
     * The MyChannel attribute is a readonly attribute which maintains the object reference
     * of the Notification Service event channel that created a given SupplierAdmin
     * instance.
     */
    readonly attribute EventChannel MyChannel;
    
    /**
     * The MyOperator attribute is a readonly attribute which maintains the information
     * regarding whether AND or OR semantics will be used during the evaluation of a given
     * event against a set of filter objects, when combining the filter objects associated with
     * the target SupplierAdmin and those defined locally on a given proxy consumer.
     */
    readonly attribute InterFilterGroupOperator MyOperator;
    /**
     * The pull_consumers attribute is a readonly attribute which contains the list of unique
     * identifiers which have been assigned by a SupplierAdmin instance to each pull-style
     * proxy consumer object it has created.
     */
    readonly attribute ProxyIDSeq pull_consumers;

    /**
     * The push_consumers attribute is a readonly attribute which contains the list of unique
     * identifiers which have been assigned by a SupplierAdmin instance to each push-style
     * proxy consumer object it has created.
     */
    readonly attribute ProxyIDSeq push_consumers;

    /**
     * The get_proxy_consumer operation accepts as an input parameter the numeric unique
     * identifier associated with one of the proxy consumer objects which has been created by
     * the target SupplierAdmin instance. If the input parameter does correspond to the
     * unique identifier of a proxy consumer object that has been created by the target
     * SupplierAdmin instance, that proxy consumer object’s reference is returned as the
     * result of the operation. Otherwise, the ProxyNotFound exception is raised.
     */
    ProxyConsumer get_proxy_consumer (
        in ProxyID proxy_id )
      raises ( ProxyNotFound );

    /**
     * The obtain_notification_pull_consumer operation can create instances of the various
     * types of pull-style proxy consumer objects defined within the
     * CosNotifyChannelAdmin module. Recall that three varieties of pull-style proxy
     * consumer objects are defined within this module: instances of the
     * ProxyPullConsumer interface support connections to pull suppliers which send events
     * as Anys, instances of the StructuredProxyPullConsumer interface support
     * connections to pull suppliers which send events as Structured Events, and instances of
     * the SequenceProxyPullConsumer interface support connections to pull suppliers
     * which send events as sequences of Structured Events.
     * The obtain_notification_pull_consumer operation thus accepts as an input parameter a
     * flag which indicates which style of pull-style proxy consumer instance should be
     * created. If the number of suppliers currently connected to the channel with which the
     * target SupplierAdmin object is associated exceeds the value of the MaxSuppliers
     * administrative property, the AdminLimitExceeded exception is raised. Otherwise, the
     * target SupplierAdmin creates the new pull-style proxy consumer instance and assigns
     * a numeric identifier to it that is unique among all proxy consumers it has created. The
     * unique identifier is returned as the output parameter of the operation, and the reference
     * to the new proxy consumer instance is returned as the operation result.
     */
    ProxyConsumer obtain_notification_pull_consumer (
        in ClientType ctype,
        out ProxyID proxy_id)
      raises ( AdminLimitExceeded );

    /**
     * The obtain_notification_push_consumer operation can create instances of the various
     * types of push-style proxy consumer objects defined within the
     * CosNotifyChannelAdmin module. Recall that three varieties of push-style proxy
     * consumer objects are defined within this module: instances of the
     * ProxyPushConsumer interface support connections to push suppliers which send
     * events as Anys, instances of the StructuredProxyPushConsumer interface support
     * connections to push suppliers which send events as Structured Events, and instances of
     * the SequenceProxyPushConsumer interface support connections to push suppliers
     * which send events as sequences of Structured Events.
     * The obtain_notification_push_consumer operation thus accepts as an input parameter a
     * flag which indicates which style of push-style proxy consumer instance should be
     * created. If the number of suppliers currently connected to the channel with which the
     * target SupplierAdmin object is associated exceeds the value of the MaxSuppliers
     * administrative property, the AdminLimitExceeded exception is raised. Otherwise, the
     * target SupplierAdmin creates the new push-style proxy consumer instance and assigns
     * a numeric identifier to it that is unique among all proxy consumers it has created. The
     * unique identifier is returned as the output parameter of the operation, and the reference
     * to the new proxy consumer instance is returned as the operation result.
     */
    ProxyConsumer obtain_notification_push_consumer (
        in ClientType ctype,
        out ProxyID proxy_id)
      raises ( AdminLimitExceeded );

    /**
     * The destroy operation can be invoked to destroy the target SupplierAdmin instance,
     * freeing all resources consumed by the instance. Note that destroy can be invoked on a
     * SupplierAdmin instance that is current managing proxy consumer objects that support
     * open connections to suppliers. In this case, the effect of invoking destroy on the
     * SupplierAdmin is that the operation will disconnect each of the proxy consumer
     * objects being managed by the target SupplierAdmin from their suppliers, and destroy
     * each of these proxy consumers. Ultimately, the SupplierAdmin instance itself will be
     * destroyed.
     */
    void destroy();

  }; // SupplierAdmin

  /**
   * The EventChannel interface encapsulates the behaviors supported by a Notification
   * Service event channel. This interface inherits from the EventChannel interface
   * defined within the CosEventChannelAdmin module of the OMG Event Service,
   * making an instance of the Notification Service EventChannel interface fully backward
   * compatible with an OMG Event Service style untyped event channel.
   * Inheritance of the EventChannel interface defined within the
   * CosEventChannelAdmin module enables an instance of the EventChannel interface
   * defined within the CosNotifyChannelAdmin module to create event service style
   * ConsumerAdmin and SupplierAdmin instances. These instances can subsequently be
   * used to create pure event service style proxy interfaces, which support connections to
   * pure event service style suppliers and consumers. Note that while Notification Service
   * style proxies and admin objects have unique identifiers associated with them, enabling
   * their references to be obtained by invoking operations on the Notification Service style
   * admin and event channel interfaces, Event Service style proxies and admin objects do
   * not have associated unique identifiers, and thus cannot be returned by invoking an
   * operation on the Notification Service style admin or event channel interfaces.
   * The EventChannel interface defined within the CosNotifyChannelAdmin module
   * also inherits from the QoSAdmin and the AdminPropertiesAdmin interfaces defined
   * within the CosNotification module. Inheritance of these interfaces enables a
   * Notification Service style event channel to manage lists of associated QoS and
   * administrative properties, respectively.
   * Locally, the EventChannel interface supports a readonly attribute which maintains a
   * reference to the EventChannelFactory instance that created it. In addition, each
   * instance of the EventChannel interface has an associated default ConsumerAdmin
   * and an associated default SupplierAdmin instance, both of which exist upon creation
   * of the channel and which have the unique identifier of zero (note that admin object
   * identifiers only need to be unique among a given type of admin, implying that the
   * identifiers assigned to ConsumerAdmin objects can overlap those assigned to
   * SupplierAdmin objects). The EventChannel interface supports readonly attributes
   * which maintain references to these default admin objects.
   * The EventChannel interface supports operations which create new ConsumerAdmin
   * and SupplierAdmin instances. In addition, the EventChannel interface supports
   * operations which can return references to the ConsumerAdmin and SupplierAdmin
   * instances associated with a given EventChannel instance, given the unique identifier
   * of an admin object as input. Finally, the EventChannel interface supports operations
   * which return the sequence of unique identifiers of all ConsumerAdmin and
   * SupplierAdmin instances associated with a given EventChannel instance.
   * 
   */
  interface EventChannel :
    CosNotification::QoSAdmin,
    CosNotification::AdminPropertiesAdmin,
    CosEventChannelAdmin::EventChannel {

    /**
     * The MyFactory attribute is a readonly attribute which maintains the object reference of
     * the event channel factory that created a given Notification Service EventChannel
     * instance.
     * 
     * @return Channel's factory
     */    
    readonly attribute EventChannelFactory MyFactory;
  
    /**
     * The default_consumer_admin attribute is a readonly attribute which maintains a
     * reference to the default ConsumerAdmin instance associated with the target
     * EventChannel instance. Each EventChannel instance has an associated default
     * ConsumerAdmin instance, which exists upon creation of the channel and is assigned
     * the unique identifier of zero. Subsequently, clients can create additional Event Service
     * style ConsumerAdmin instances by invoking the inherited for_consumers operation,
     * and additional Notification Service style ConsumerAdmin instances by invoking the
     * new_for_consumers operation defined by the EventChannel interface.
     * 
     * @return the default consumer admin
     */
    readonly attribute CosNotifyChannelAdmin::ConsumerAdmin default_consumer_admin;
    
    /**
     * 
     * The default_supplier_admin attribute is a readonly attribute which maintains a
     * reference to the default SupplierAdmin instance associated with the target
     * EventChannel instance. Each EventChannel instance has an associated default
     * SupplierAdmin instance, which exists upon creation of the channel and is assigned
     * the unique identifier of zero. Subsequently, clients can create additional Event Service
     * style SupplierAdmin instances by invoking the inherited for_suppliers operation, and
     * additional Notification Service style SupplierAdmin instances by invoking the
     * new_for_suppliers operation defined by the EventChannel interface.
     * 
     * @return the default supplier admin
     */
    readonly attribute CosNotifyChannelAdmin::SupplierAdmin default_supplier_admin;
  
    /**
     * The default_filter_factory attribute is a readonly attribute which maintains an object
     * reference to the default factory to be used by the EventChannel instance with which
     * it is associated for creating filter objects. If the target channel does not support a
     * default filter factory, the attribute will maintain the value of OBJECT_NIL.
     * 
     * @return the default filter factory
     */
    readonly attribute CosNotifyFilter::FilterFactory
            default_filter_factory;
    /**
     * 
     * The new_for_consumers operation is invoked to create a new Notification Service style
     * ConsumerAdmin instance. The operation accepts as an input parameter a boolean flag
     * which indicates whether AND or OR semantics will be used when combining the filter
     * objects associated with the newly created ConsumerAdmin instance with those
     * associated with a supplier proxy which was created by the ConsumerAdmin during
     * the evaluation of each event against a set of filter objects. The new instance is assigned
     * a unique identifier by the target EventChannel instance that is unique among all
     * ConsumerAdmin instances currently associated with the channel. Upon completion,
     * the operation returns the reference to the new ConsumerAdmin instance as the result
     * of the operation, and the unique identifier assigned to the new ConsumerAdmin
     * instance as the output parameter.
     * 
     * @param op Operator of Filters' composition (between consumer filters and proxies filters)
     * @param id Id of the new consumer admin
     * @return The new consumer Admin
     *
     */
    CosNotifyChannelAdmin::ConsumerAdmin new_for_consumers(
        in InterFilterGroupOperator op,
        out AdminID id );
    
    /**    
     * The new_for_suppliers operation is invoked to create a new Notification Service style
     * SupplierAdmin instance. The operation accepts as an input parameter a boolean flag
     * which indicates whether AND or OR semantics will be used when combining the filter
     * objects associated with the newly created SupplierAdmin instance with those
     * associated with a consumer proxy which was created by the SupplierAdmin during
     * the evaluation of each event against a set of filter objects. The new instance is assigned
     * a unique identifier by the target EventChannel instance that is unique among all
     * SupplierAdmin instances currently associated with the channel. Upon completion, the
     * operation returns the reference to the new SupplierAdmin instance as the result of the
     * operation, and the unique identifier assigned to the new SupplierAdmin instance as
     * the output parameter.
     * 
     * @param op Operator of Filters' composition (between supplier filters and proxies filters)
     * @param id Id of the new consumer admin
     * @return The new supplier Admin
     */
    CosNotifyChannelAdmin::SupplierAdmin new_for_suppliers(
        in InterFilterGroupOperator op,
        out AdminID id );
    
    /**
     * The get_consumeradmin operation returns a reference to one of the ConsumerAdmin
     * instances associated with the target EventChannel instance. The operation accepts as
     * an input parameter a numeric value which is intended to be the unique identifier of one
     * of the ConsumerAdmin instances associated with the target EventChannel instance.
     * If this turns out to be the case, the object reference of the associated ConsumerAdmin
     * instance is returned as the operation result. Otherwise, the AdminNotFound exception
     * is raised.
     * Note that while a Notification Service style event channel can support both Event
     * Service and Notification Service style ConsumerAdmin instances, only Notification
     * Service style ConsumerAdmin instances have associated unique identifiers.
     * 
     * @param id Id of consumer admin to retreive
     * @return The requested consumer admin
     * @exception org.omg.CosNotifyChannelAdmin.AdminNotFound Id doesn't correspond to any consumer admin
     */
    CosNotifyChannelAdmin::ConsumerAdmin get_consumeradmin ( in AdminID id )
      raises (AdminNotFound);
    
    /**
     * 
     * The get_supplieradmin operation returns a reference to one of the SupplierAdmin
     * instances associated with the target EventChannel instance. The operation accepts as
     * an input parameter a numeric value which is intended to be the unique identifier of one
     * of the SupplierAdmin instances associated with the target EventChannel instance. If
     * this turns out to be the case, the object reference of the associated SupplierAdmin
     * instance is returned as the operation result. Otherwise, the AdminNotFound exception
     * is raised.
     * Note that while a Notification Service style event channel can support both Event
     * Service and Notification Service style SupplierAdmin instances, only Notification
     * Service style SupplierAdmin instances have associated unique identifiers.
     * 
     * @param id Id of supplier admin to retreive
     * @return The requested supplier admin
     * @exception org.omg.CosNotifyChannelAdmin.AdminNotFound Id doesn't correspond to any supplier admin
     */
    CosNotifyChannelAdmin::SupplierAdmin get_supplieradmin ( in AdminID id )
      raises (AdminNotFound);
    
    /**
     * The get_all_consumeradmins operation takes no input parameters and returns a
     * sequence of the unique identifiers assigned to all Notification Service style
     * ConsumerAdmin instances which have been created by the target EventChannel
     * instance.
     * 
     * @return Array of all consumer admin ID
     */
    AdminIDSeq get_all_consumeradmins();
   
    /**
     * The get_all_supplieradmins operation takes no input parameters and returns a
     * sequence of the unique identifiers assigned to all Notification Service style
     * SupplierAdmin instances which have been created by the target EventChannel
     * instance.
     * 
     * @return Array of all supplier admin ID
     * 
     */
    AdminIDSeq get_all_supplieradmins();

  }; // EventChannel

  typedef long ChannelID;
  typedef sequence<ChannelID> ChannelIDSeq;

  exception ChannelNotFound {};

  /**
   * The EventChannelFactory interface defines operations for creating and managing
   * new Notification Service style event channels. It supports a routine that creates new
   * instances of Notification Service event channels and assigns unique numeric identifiers
   * to them. In addition, the EventChannelFactory interface supports a routine which can
   * return the unique identifiers assigned to all event channels created by a given instance
   * of EventChannelFactory, and another routine which, given the unique identifier of an
   * event channel created by a target EventChannelFactory instance, returns the object
   * reference of that event channel.
   */
  interface EventChannelFactory {

    /**
     *   The create_channel operation is invoked to create a new instance of the Notification
     * Service style event channel. This operation accepts two input parameters. The first
     * input parameter is a list of name-value pairs which specify the initial QoS property
     * settings for the new channel. The second input parameter is a list of name-value pairs
     * which specify the initial administrative property settings for the new channel.
     * If no implementation of the EventChannel interface exists that can support all of the
     * requested QoS property settings, the UnsupportedQoS exception is raised. This
     * exception contains as data a sequence of data structures, each of which identifies the
     * name of a QoS property in the input list whose requested setting could not be satisfied,
     * along with an error code and a range of settings for the property which could be
     * satisfied. The meanings of the error codes which might be returned are described in
     * Table 2-5.
     * Likewise, if no implementation of the EventChannel interface exists that can support
     * all of the requested administrative property settings, the UnsupportedAdmin
     * exception is raised. This exception contains as data a sequence of data structures, each
     * of which identifies the name of an administrative property in the input list whose
     * requested setting could not be satisfied, along with an error code and a range of
     * settings for the property which could be satisfied. The meanings of the error codes
     * which might be returned are described in Table 2-5.
     * If neither of these exceptions is raised, the create_channel operation will return a
     * reference to a new Notification Service style event channel. In addition, the operation
     * assigns to this new event channel a numeric identifier which is unique among all event
     * channels created by the target object. This numeric identifier is returned as an output
     * parameter.
     */
    EventChannel create_channel (
      in CosNotification::QoSProperties initial_qos,
      in CosNotification::AdminProperties initial_admin,
        out ChannelID id)
      raises(CosNotification::UnsupportedQoS,
          CosNotification::UnsupportedAdmin );

    /**
     *   The get_all_channels operation returns a sequence of all of the unique numeric
     * identifiers corresponding to Notification Service event channels which have been
     * created by the target object.
     */
    ChannelIDSeq get_all_channels();

    /**
     * The get_event_channel operation accepts as input a numeric value which is supposed
     * to be the unique identifier of a Notification Service event channel that has been created
     * by the target object. If this input value does not correspond to such a unique identifier,
     * the ChannelNotFound exception is raised. Otherwise, the operation returns the object
     * reference of the Notification Service event channel corresponding to the input
     * identifier.
     * 
     */
    EventChannel get_event_channel ( in ChannelID id )
      raises (ChannelNotFound);

  }; // EventChannelFactory

}; // CosNotifyChannelAdmin

#endif // _COS_NOTIFY_CHANNEL_ADMIN_IDL_
