#ifndef _COS_NOTIFY_CHANNEL_ADMIN_IDL
#define _COS_NOTIFY_CHANNEL_ADMIN_IDL

#include "CosEventChannelAdmin.idl"
#include "CosNotifyFilter.idl"

#pragma prefix "omg.org"

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 StructuredProxyPushConsumer :
								ProxyConsumer,
								CosNotifyComm::StructuredPushConsumer {
		void connect_structured_push_supplier (
				in CosNotifyComm::StructuredPushSupplier push_supplier)
				raises(CosEventChannelAdmin::AlreadyConnected);
	}; // StructuredProxyPushConsumer

	interface SequenceProxyPushConsumer :
								ProxyConsumer,
								CosNotifyComm::SequencePushConsumer {
		void connect_sequence_push_supplier (
				in CosNotifyComm::SequencePushSupplier push_supplier)
				raises(CosEventChannelAdmin::AlreadyConnected);
	}; // SequenceProxyPushConsumer

	interface ProxyPullSupplier :
						ProxySupplier,
						CosNotifyComm::NotifySubscribe,
						CosEventComm::PullSupplier {
		void connect_any_pull_consumer (
				in CosEventComm::PullConsumer pull_consumer)
				raises(CosEventChannelAdmin::AlreadyConnected);
	}; // ProxyPullSupplier

	interface StructuredProxyPullSupplier :
								ProxySupplier,
								CosNotifyComm::StructuredPullSupplier {
		void connect_structured_pull_consumer (
				in CosNotifyComm::StructuredPullConsumer pull_consumer)
				raises(CosEventChannelAdmin::AlreadyConnected);
	}; // StructuredProxyPullSupplier

	interface SequenceProxyPullSupplier :
								ProxySupplier,
								CosNotifyComm::SequencePullSupplier {
		void connect_sequence_pull_consumer (
				in CosNotifyComm::SequencePullConsumer pull_consumer)
				raises(CosEventChannelAdmin::AlreadyConnected);
	}; // SequenceProxyPullSupplier

	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
	};

	typedef long AdminID;
	typedef sequence<AdminID> AdminIDSeq;

	exception AdminNotFound {};

	exception ProxyNotFound {};

	interface ConsumerAdmin :
					CosNotification::QoSAdmin,
					CosNotifyComm::NotifySubscribe,
					CosNotifyFilter::FilterAdmin,
					CosEventChannelAdmin::ConsumerAdmin {
		readonly attribute AdminID MyID;
		readonly attribute EventChannel MyChannel;
		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);
		ProxySupplier obtain_notification_push_supplier (
							in ClientType ctype,
							out ProxyID proxy_id);
	}; // ConsumerAdmin

	interface SupplierAdmin :
					CosNotification::QoSAdmin,
					CosNotifyComm::NotifyPublish,
					CosNotifyFilter::FilterAdmin,
					CosEventChannelAdmin::SupplierAdmin {
		readonly attribute AdminID MyID;
		readonly attribute EventChannel MyChannel;
		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);
		ProxyConsumer obtain_notification_push_consumer (
							in ClientType ctype,
							out ProxyID proxy_id);
	}; // 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;

		ConsumerAdmin new_for_consumers( out AdminID id );
		SupplierAdmin new_for_suppliers( 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

#endif