[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[COAS-List] Notification IDL
y'all
i'll post this and other files to the Protocol FTP site.
larry
----------
From: "Michael J. Greenberg" <mjg@syl.nj.nec.com>
Subject: Re: Notification IDL
To: larryh@medgrid.philips.com (Larry Hamel)
Date: Thu, 13 Aug 1998 18:05:49 -0400 (EDT)
X-Mailer: ELM [version 2.4ME+ PL40 (25)]
Hi Larry,
Here's the IDL from the recently adopted spec. I should point out to you
that the RTF for Notification will certainly be incorporating several
changes to this IDL. The results of the RTF will not be available until
December, however.
Regards,
Mike
--
Michael J. Greenberg
NEC Systems Lab.
4 Independence Way Tel. 609-734-6142
Princeton, NJ 08540 Fax. 609-734-6001
mjg@syl.nj.nec.com
----------------------------------------------------------------------------
module CosNotification {
// The following two are the same, but serve different purposes.
typedef CosTrading::PropertySeq OptionalHeaderFields;
typedef CosTrading::PropertySeq FilterableEventBody;
typedef CosTrading::PropertySeq QoSProperties;
typedef CosTrading::PropertySeq AdminProperties;
struct EventType {
string domain_name;
string type_name;
};
typedef sequence<EventType> EventTypeSeq;
struct PropertyRange {
CosTrading::PropertyName name;
CosTrading::PropertyValue low_val;
CosTrading::PropertyValue high_val;
};
typedef sequence<PropertyRange> PropertyRangeSeq;
enum QoSError_code {
UNSUPPORTED_PROPERTY,
UNAVAILABLE_PROPERTY,
UNSUPPORTED_VALUE,
UNAVAILABLE_VALUE,
BAD_PROPERTY,
BAD_TYPE,
BAD_VALUE
};
struct PropertyError {
QoSError_code code;
PropertyRange available_range;
};
typedef sequence<PropertyError> PropertyErrorSeq;
exception UnsupportedQoS { PropertyErrorSeq qos_err; };
exception UnsupportedAdmin { PropertyErrorSeq admin_err; };
// Define the Structured Event structure
struct FixedEventHeader {
EventType event_type;
string event_name;
};
struct EventHeader {
FixedEventHeader fixed_header;
OptionalHeaderFields variable_header;
};
struct StructuredEvent {
EventHeader header;
FilterableEventBody filterable_data;
any remainder_of_body;
}; // StructuredEvent
typedef sequence<StructuredEvent> EventBatch;
// The following constant declarations define the standard
// QoS property names and the associated values each property
// can take on. The name/value pairs for each standard property
// are grouped, beginning with a string constant defined for the
// property name, followed by the values the property can take on.
const string EventReliability = "EventReliability";
const short BestEffort = 0;
const short Persistent = 1;
const string ConnectionReliability = "ConnectionReliability";
// Can take on the same values as EventReliability
const string Priority = "Priority";
const short LowestPriority = -32767;
const short HighestPriority = 32767;
const short DefaultPriority = 0;
const string StartTime = "StartTime";
// StartTime takes a value of type TimeBase::UtcT when placed
// in an event header. StartTime can also be set to either
// TRUE or FALSE at the Proxy level, indicating whether or not the
// Proxy supports the setting of per-message stop times.
const string StopTime = "StopTime";
// StopTime takes a value of type TimeBase::UtcT when placed
// in an event header. StopTime can also be set to either
// TRUE or FALSE at the Proxy level, indicating whether or not the
// Proxy supports the setting of per-message stop times.
const string Timeout = "Timeout";
// Timeout takes on a value of type TimeBase::TimeT
const string OrderPolicy = "OrderPolicy";
const short AnyOrder = 0;
const short FifoOrder = 1;
const short PriorityOrder = 2;
const short DeadlineOrder = 3;
const string DiscardPolicy = "DiscardPolicy";
// DiscardPolicy takes on the same values as OrderPolicy, plus
const short LifoOrder = 4;
const string MaximumBatchSize = "MaximumBatchSize";
// MaximumBatchSize takes on a value of type long
const string PacingInterval = "PacingInterval";
// PacingInterval takes on a value of type TimeBase::TimeT
interface QoSAdmin {
QoSProperties get_qos();
void set_qos ( in QoSProperties qos)
raises ( UnsupportedQoS );
void validate_qos (
in QoSProperites required_qos,
out PropertyRangeSeq available_qos )
raises ( UnsupportedQoS );
}; // QosAdmin
// Admin properties are defined in similar manner as QoS
// properties. The only difference is that these properties
// are related to channel administration policies, as opposed
// message quality of service
const string MaxQueueLength = "MaxQueueLength";
// MaxQueueLength takes on a value of type long
const string MaxConsumers = "MaxConsumers";
// MaxConsumers takes on a value of type long
const string MaxSuppliers = "MaxSuppliers";
// MaxSuppliers takes on a value of type long
interface AdminPropertiesAdmin {
AdminProperites get_admin();
void set_admin (in AdminProperties admin)
raises ( UnsupportedAdmin);
}; // AdminPropertiesAdmin
}; // CosNotification
module CosNotifyFilter {
typedef long ConstraintID;
struct ConstraintExp {
CosNotification::EventTypeSeq event_types;
string constraint_expr;
};
typedef sequence<ConstraintID> ConstraintIDSeq;
typedef sequence<ConstraintExp> ConstraintExpSeq;
struct ConstraintInfo {
ConstraintExp constraint_expression;
ConstraintID constraint_id;
};
typedef sequence<ConstraintInfo> ConstraintInfoSeq;
struct MappingConstraintPair {
ConstraintExp constraint_expression;
any result_to_set;
};
typedef sequence<MappingConstraintPair> MappingConstraintPairSeq;
struct MappingConstraintInfo {
ConstraintExp constraint_expression;
ConstraintID constraint_id;
any value;
};
typedef sequence<MappingConstraintInfo> MappingConstraintInfoSeq;
typedef long CallbackID;
typedef sequence<CallbackID> CallbackIDSeq;
exception UnsupportedFilterableData {};
exception InvalidGrammar {};
exception InvalidConstraint {ConstraintExp constr;};
exception DuplicateConstraintID {ConstraintID id;};
exception ConstraintNotFound {ConstraintID id;};
exception CallbackNotFound {};
exception InvalidValue {ConstraintExp constr; any value;};
interface Filter {
readonly attribute string constraint_grammar;
ConstraintInfoSeq add_constraints (
in ConstraintExpSeq constraint_list)
raises (InvalidConstraint);
void modify_constraints (
in ConstraintIDSeq del_list,
in ConstraintInfoSeq modify_list)
raises (InvalidConstraint, ConstraintNotFound);
ConstraintInfoSeq get_constraints(
in ConstraintIDSeq id_list)
raises (ConstraintNotFound);
ConstraintInfoSeq get_all_constraints();
void remove_all_constraints();
void destroy();
boolean match ( in any filterable_data )
raises (UnsupportedFilterableData);
boolean match_structured (
in CosNotification::StructuredEvent filterable_data )
raises (UnsupportedFilterableData);
boolean match_typed (
in CosTrading::PropertySeq filterable_data )
raises (UnsupportedFilterableData);
CallbackID attach_callback (
in CosNotifyComm::NotifySubscribe callback);
void detach_callback ( in CallbackID callback)
raises ( CallbackNotFound );
CallbackIDSeq get_callbacks();
}; // Filter
interface MappingFilter {
readonly attribute string constraint_grammar;
readonly attribute CORBA::TypeCode value_type;
readonly attribute any default_value;
MappingConstraintInfoSeq add_mapping_constraints (
in MappingConstraintPairSeq pair_list)
raises (InvalidConstraint, InvalidValue);
void modify_mapping_constraints (
in ConstraintIDSeq del_list,
in MappingConstraintInfoSeq modify_list)
raises (InvalidConstraint, InvalidValue,
ConstraintNotFound);
MappingConstraintInfoSeq get_mapping_constraints (
in ConstraintIDSeq id_list)
raises (ConstraintNotFound);
MappingConstraintInfoSeq get_all_mapping_constraints();
void remove_all_mapping_constraints();
void destroy();
boolean match ( in any filterable_data,
out any result_to_set )
raises (UnsupportedFilterableData);
boolean match_structured (
in CosNotification::StructuredEvent filterable_data,
out any result_to_set)
raises (UnsupportedFilterableData);
boolean match_typed (
in CosTrading::PropertySeq filterable_data,
out any result_to_set)
raises (UnsupportedFilterableData);
}; // MappingFilter
interface FilterFactory {
Filter create_filter (
in string constraint_grammar)
raises (InvalidGrammar);
MappingFilter create_mapping_filter (
in string constraint_grammar,
in any default_value)
raises(InvalidGrammar);
}; // FilterFactory
typedef long FilterID;
typedef sequence<FilterID> FilterIDSeq;
exception FilterNotFound {};
interface FilterAdmin {
FilterID add_filter ( in Filter new_filter );
void remove_filter ( in FilterID filter )
raises ( FilterNotFound );
Filter get_filter ( in FilterID filter )
raises ( FilterNotFound );
FilterIDSeq get_all_filters();
void remove_all_filters();
}; // FilterAdmin
}; // CosNotifyFilter
module CosNotifyComm {
exception InvalidEventType { CosNotification::EventType type; };
interface NotifyPublish {
void offer_change (
in CosNotification::EventTypeSeq added,
in CosNotification::EventTypeSeq removed )
raises ( InvalidEventType );
}; // NotifyPublish
interface NotifySubscribe {
void subscription_change(
in CosNotification::EventTypeSeq added,
in CosNotification::EventTypeSeq removed )
raises ( InvalidEventType );
}; // NotifySubscribe
interface TxnPushConsumer :
NotifyPublish,
CosEventComm::PushConsumer,
CosTransactions::TransactionalObject {
}; // TxnPushConsumer
interface TxnPullSupplier :
NotifySubscribe,
CosEventComm::PullSupplier,
CosTransactions::TransactionalObject {
}; // TxnPullSupplier
interface StructuredPushConsumer : NotifyPublish {
void push_structured_event(
in CosNotification::StructuredEvent notification)
raises(CosEventComm::Disconnected);
void disconnect_structured_push_consumer();
}; // StructuredPushConsumer
interface TxnStructuredPushConsumer :
StructuredPushConsumer,
CosTransactions::TransactionalObject {
}; // TxnStructuredPushConsumer
interface StructuredPullConsumer : NotifyPublish {
void disconnect_structured_pull_consumer();
}; // StructuredPullConsumer
interface StructuredPullSupplier : NotifySubscribe {
CosNotification::StructuredEvent pull_structured_event()
raises(CosEventComm::Disconnected);
CosNotification::StructuredEvent try_pull_structured_event(
out boolean has_event)
raises(CosEventComm::Disconnected);
void disconnect_structured_pull_supplier();
}; // StructuredPullSupplier
interface TxnStructuredPullSupplier :
StructuredPullSupplier,
CosTransactions::TransactionalObject {
}; // TxnStructuredPullSupplier
interface StructuredPushSupplier : NotifySubscribe {
void disconnect_structured_push_supplier();
}; // StructuredPushSupplier
interface SequencePushConsumer : NotifyPublish {
void push_structured_events(
in CosNotification::EventBatch notifications)
raises(CosEventComm::Disconnected);
void disconnect_sequence_push_consumer();
}; // SequencePushConsumer
interface TxnSequencePushConsumer :
SequencePushConsumer,
CosTransactions::TransactionalObject {
}; // TxnSequencePushConsumer
interface SequencePullConsumer : NotifyPublish {
void disconnect_sequence_pull_consumer();
}; // SequencePullConsumer
interface SequencePullSupplier : NotifySubscribe {
CosNotification::EventBatch pull_structured_events(
in long max_number )
raises(CosEventComm::Disconnected);
CosNotification::StructuredEvent try_pull_structured_events(
in long max_number,
out boolean has_event)
raises(CosEventComm::Disconnected);
void disconnect_sequence_pull_supplier();
}; // SequencePullSupplier
interface TxnSequencePullSupplier :
SequencePullSupplier,
CosTransactions::TransactionalObject {
}; // TxnSequencePullSupplier
interface SequencePushSupplier : NotifySubscribe {
void disconnect_sequence_push_supplier();
}; // SequencePushSupplier
}; // CosNotifyComm
module CosNotifyChannelAdmin {
exception ConnectionAlreadyActive {};
exception ConnectionAlreadyInactive {};
// Forward declarations
interface ConsumerAdmin;
interface SupplierAdmin;
interface EventChannel;
interface EventChannelFactory;
interface ProxyConsumer :
CosNotification::QoSAdmin,
CosNotifyFilter::FilterAdmin {
readonly attribute SupplierAdmin MyAdmin;
CosNotification::EventTypeSeq obtain_subscription_types();
void validate_event_qos (
in CosNotification::QoSProperties required_qos,
out CosNotification::PropertyRangeSeq available_qos)
raises (CosNotification::UnsupportedQoS);
}; // ProxyConsumer
interface ProxySupplier :
CosNotification::QoSAdmin,
CosNotifyFilter::FilterAdmin {
readonly attribute ConsumerAdmin MyAdmin;
attribute CosNotifyFilter::MappingFilter priority_filter;
attribute CosNotifyFilter::MappingFilter lifetime_filter;
CosNotification::EventTypeSeq obtain_offered_types();
void validate_event_qos (
in CosNotification::QoSProperties required_qos,
out CosNotification::PropertyRangeSeq available_qos)
raises (CosNotification::UnsupportedQoS);
}; // ProxySupplier
interface ProxyPushConsumer :
ProxyConsumer,
CosNotifyComm::NotifyPublish,
CosEventComm::PushConsumer {
void connect_any_push_supplier (
in CosEventComm::PushSupplier push_supplier)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // ProxyPushConsumer
interface TxnProxyPushConsumer :
ProxyPushConsumer,
CosTransactions::TransactionalObject {
}; TxnProxyPushConsumer
interface StructuredProxyPushConsumer :
ProxyConsumer,
CosNotifyComm::StructuredPushConsumer {
void connect_structured_push_supplier (
in CosNotifyComm::StructuredPushSupplier push_supplier)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // StructuredProxyPushConsumer
interface TxnStructuredProxyPushConsumer :
StructuredProxyPushConsumer,
CosTransactions::TransactionalObject {
}; // TxnStructuredPushConsumer
interface SequenceProxyPushConsumer :
ProxyConsumer,
CosNotifyComm::SequencePushConsumer {
void connect_sequence_push_supplier (
in CosNotifyComm::SequencePushSupplier push_supplier)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // SequenceProxyPushConsumer
interface TxnSequenceProxyPushConsumer :
SequenceProxyPushConsumer,
CosTransactions::TransactionalObject {
}; // TxnSequencePushConsumer
interface ProxyPullSupplier :
ProxySupplier,
CosNotifyComm::NotifySubscribe,
CosEventComm::PullSupplier {
void connect_any_pull_consumer (
in CosEventComm::PullConsumer pull_consumer)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // ProxyPullSupplier
interface TxnProxyPullSupplier :
ProxyPullSupplier,
CosTransactions::TransactionalObject {
}; // TxnProxyPullSupplier
interface StructuredProxyPullSupplier :
ProxySupplier,
CosNotifyComm::StructuredPullSupplier {
void connect_structured_pull_consumer (
in CosNotifyComm::StructuredPullConsumer pull_consumer)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // StructuredProxyPullSupplier
interface TxnStructuredProxyPullSupplier :
StructuredProxyPullSupplier,
CosTransactions::TransactionalObject {
}; // TxnStructuredProxyPullSupplier
interface SequenceProxyPullSupplier :
ProxySupplier,
CosNotifyComm::SequencePullSupplier {
void connect_sequence_pull_consumer (
in CosNotifyComm::SequencePullConsumer pull_consumer)
raises(CosEventChannelAdmin::AlreadyConnected);
}; // SequenceProxyPullSupplier
interface TxnSequenceProxyPullSupplier :
SequenceProxyPullSupplier,
CosTransactions::TransactionalObject {
}; // TxnSequenceProxyPullSupplier
interface ProxyPullConsumer :
ProxyConsumer,
CosNotifyComm::NotifyPublish,
CosEventComm::PullConsumer {
void connect_any_pull_supplier (
in CosEventComm::PullSupplier pull_supplier)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
}; // ProxyPullConsumer
interface StructuredProxyPullConsumer :
ProxyConsumer,
CosNotifyComm::StructuredPullConsumer {
void connect_structured_pull_supplier (
in CosNotifyComm::StructuredPullSupplier pull_supplier)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
}; // StructuredProxyPullConsumer
interface SequenceProxyPullConsumer :
ProxyConsumer,
CosNotifyComm::SequencePullConsumer {
void connect_sequence_pull_supplier (
in CosNotifyComm::SequencePullSupplier pull_supplier)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
}; // SequenceProxyPullConsumer
interface ProxyPushSupplier :
ProxySupplier,
CosNotifyComm::NotifySubscribe,
CosEventComm::PushSupplier {
void connect_any_push_consumer (
in CosEventComm::PushConsumer push_consumer)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
void suspend_connection()
raises(ConnectionAlreadyInactive);
void resume_connection()
raises(ConnectionAlreadyActive);
}; // ProxyPushSupplier
interface StructuredProxyPushSupplier :
ProxySupplier,
CosNotifyComm::StructuredPushSupplier {
void connect_structured_push_consumer (
in CosNotifyComm::StructuredPushConsumer push_consumer)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
void suspend_connection()
raises(ConnectionAlreadyInactive);
void resume_connection()
raises(ConnectionAlreadyActive);
}; // StructuredProxyPushSupplier
interface SequenceProxyPushSupplier :
ProxySupplier,
CosNotifyComm::SequencePushSupplier {
void connect_sequence_push_consumer (
in CosNotifyComm::SequencePushConsumer push_consumer)
raises(CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
void suspend_connection()
raises(ConnectionAlreadyInactive);
void resume_connection()
raises(ConnectionAlreadyActive);
}; // 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 {
CosTrading::PropertyName name;
CosTrading::PropertyValue value;
};
exception AdminLimitExceeded { AdminLimit admin_property_err; };
interface ConsumerAdmin :
CosNotification::QoSAdmin,
CosNotifyComm::NotifySubscribe,
CosNotifyFilter::FilterAdmin,
CosEventChannelAdmin::ConsumerAdmin {
readonly attribute AdminID MyID;
readonly attribute EventChannel MyChannel;
readonly attribute InterFilterGroupOperator MyOperator;
attribute CosNotifyFilter::MappingFilter priority_filter;
attribute CosNotifyFilter::MappingFilter lifetime_filter;
readonly attribute ProxyIDSeq pull_suppliers;
readonly attribute ProxyIDSeq push_suppliers;
ProxySupplier get_proxy_supplier (
in ProxyID proxy_id )
raises ( ProxyNotFound );
ProxySupplier obtain_notification_pull_supplier (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
ProxySupplier obtain_notification_push_supplier (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
ProxySupplier obtain_txn_notification_pull_supplier (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
}; // ConsumerAdmin
interface SupplierAdmin :
CosNotification::QoSAdmin,
CosNotifyComm::NotifyPublish,
CosNotifyFilter::FilterAdmin,
CosEventChannelAdmin::SupplierAdmin {
readonly attribute AdminID MyID;
readonly attribute EventChannel MyChannel;
readonly attribute InterFilterGroupOperator MyOperator;
readonly attribute ProxyIDSeq pull_consumers;
readonly attribute ProxyIDSeq push_consumers;
ProxyConsumer get_proxy_consumer (
in ProxyID proxy_id )
raises ( ProxyNotFound );
ProxyConsumer obtain_notification_pull_consumer (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
ProxyConsumer obtain_notification_push_consumer (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
ProxyConsumer obtain_txn_notification_push_consumer (
in ClientType ctype,
out ProxyID proxy_id)
raises ( AdminLimitExceeded );
}; // SupplierAdmin
interface EventChannel :
CosNotification::QoSAdmin,
CosNotification::AdminPropertiesAdmin,
CosEventChannelAdmin::EventChannel {
readonly attribute EventChannelFactory MyFactory;
readonly attribute ConsumerAdmin default_consumer_admin;
readonly attribute SupplierAdmin default_supplier_admin;
readonly attribute CosNotifyFilter::FilterFactory default_filter_factory;
ConsumerAdmin new_for_consumers(
in InterFilterGroupOperator op,
out AdminID id );
SupplierAdmin new_for_suppliers(
in InterFilterGroupOperator op,
out AdminID id );
ConsumerAdmin get_consumeradmin ( in AdminID id )
raises (AdminNotFound);
SupplierAdmin get_supplieradmin ( in AdminID id )
raises (AdminNotFound);
AdminIDSeq get_all_consumeradmins();
AdminIDSeq get_all_supplieradmins();
}; // EventChannel
typedef long ChannelID;
typedef sequence<ChannelID> ChannelIDSeq;
exception ChannelNotFound {};
interface EventChannelFactory {
EventChannel create_channel (
in CosNotification::QoSProperties initial_qos,
in CosNotification::AdminProperties initial_admin,
out ChannelID id)
raises(CosNotification::UnsupportedQoS,
CosNotification::UnsupportedAdmin );
ChannelIDSeq get_all_channels();
EventChannel get_event_channel ( in ChannelID id )
raises (ChannelNotFound);
}; // EventChannelFactory
}; // CosNotifyChannelAdmin
module CosTypedNotifyChannelAdmin {
typedef string Key;
interface TypedProxyPushConsumer :
CosNotifyChannelAdmin::ProxyConsumer,
CosNotifyComm::NotifyPublish
CosTypedEventComm:TypedPushConsumer {
void connect_typed_push_supplier (
in CosEventComm::PushSupplier push_supplier )
raises ( CosEventChannelAdmin::AlreadyConnected );
}; // TypedProxyPushConsumer
interface TypedProxyPullSupplier :
CosNotifyChannelAdmin::ProxySupplier,
CosNotifyComm::NotifySubscribe,
CosTypedEventComm::TypedPullSupplier {
void connect_typed_pull_consumer (
in CosEventComm::PullConsumer pull_consumer )
raises ( CosEventChannelAdmin::AlreadyConnected );
}; // TypedProxyPullSupplier
interface TypedProxyPullConsumer :
CosNotifyChannelAdmin::ProxyConsumer,
CosNotifyComm::NotifyPublish,
CosEventComm::PullConsumer {
void connect_typed_pull_supplier (
in CosTypedEventComm::TypedPullSupplier pull_supplier )
raises ( CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
}; // TypedProxyPullConsumer
interface TypedProxyPushSupplier :
CosNotifyChannelAdmin::ProxySupplier,
CosNotifyComm::NotifySubscribe,
CosEventComm::PushSupplier {
void connect_typed_push_consumer (
in CosTypedEventComm::TypedPushConsumer push_consumer )
raises ( CosEventChannelAdmin::AlreadyConnected,
CosEventChannelAdmin::TypeError );
void suspend_connection()
raises (CosNotifyChannelAdmin::ConnectionAlreadyInactive);
void resume_connection()
raises (CosNotifyChannelAdmin::ConnectionAlreadyActive);
}; // TypedProxyPushSupplier
interface TypedConsumerAdmin :
CosNotifyChannelAdmin::ConsumerAdmin,
CosTypedEventChannelAdmin::TypedConsumerAdmin {
TypedProxyPullSupplier obtain_typed_notification_pull_supplier(
in Key supported_interface,
out CosNotifyChannelAdmin::ProxyID proxy_id )
raises( CosTypedEventChannelAdmin::InterfaceNotSupported,
CosNotifyChannelAdmin::AdminLimitExceeded );
TypedProxyPushSupplier obtain_typed_notification_push_supplier(
in Key uses_interface,
out CosNotifyChannelAdmin::ProxyID proxy_id )
raises( CosTypedEventChannelAdmin::NoSuchImplementation,
CosNotifyChannelAdmin::AdminLimitExceeded );
}; // TypedConsumerAdmin
interface TypedSupplierAdmin :
CosNotifyChannelAdmin::SupplierAdmin,
CosTypedEventChannelAdmin::TypedSupplierAdmin {
TypedProxyPushConsumer obtain_typed_notification_push_consumer(
in Key supported_interface,
out CosNotifyChannelAdmin::ProxyID proxy_id )
raises( CosTypedEventChannelAdmin::InterfaceNotSupported,
CosNotifyChannelAdmin::AdminLimitExceeded );
TypedProxyPullConsumer obtain_typed_notification_pull_consumer(
in Key uses_interface,
out CosNotifyChannelAdmin::ProxyID proxy_id )
raises( CosTypedEventChannelAdmin::NoSuchImplementation,
CosNotifyChannelAdmin::AdminLimitExceeded );
}; // TypedSupplierAdmin
interface TypedEventChannel :
CosNotifyChannelAdmin::EventChannel,
CosTypedEventChannelAdmin::TypedEventChannel {
TypedConsumerAdmin new_for_typed_notification_consumers(
in CosNotifyChannelAdmin::InterFilterGroupOperator op,
out CosNotifyChannelAdmin::AdminID id );
TypedSupplierAdmin new_for_typed_notification_suppliers(
in CosNotifyChannelAdmin::InterFilterGroupOperator op,
out CosNotifyChannelAdmin::AdminID id );
}; // TypedEventChannel
interface TypedEventChannelFactory :
CosNotifyChannelAdmin::EventChannelFactory {
TypedEventChannel create_typed_channel (
in CosNotification::QoSProperties initial_QoS,
in CosNotification::AdminProperties initial_admin,
out CosNotifyChannelAdmin::ChannelID id)
raises( CosNotification::UnsupportedQoS,
CosNotification::UnsupportedAdmin );
}; // TypedEventChannelFactory
}; // CosTypedNotifyChannelAdmin