ChangeLogTag: Tue Sep 30 11:51:17 2003 George Edwards <g.edwards@vanderbilt.edu>

7 files changed, 832 insertions, 82 deletions

diff --git a/TAO/CIAO/ChangeLog_EC b/TAO/CIAO/ChangeLog_EC
index 98f661ca033..f7c18666c40 100644
--- a/TAO/CIAO/ChangeLog_EC
+++ b/TAO/CIAO/ChangeLog_EC
@@ -1,3 +1,14 @@
+Tue Sep 30 11:51:17 2003  George Edwards <g.edwards@vanderbilt.edu>
+
+        * ciao/CIAO_Events.h:
+        * ciao/CIAO_Events.cpp:
+        * ciao/CIAO_Events.idl:
+        * examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp:
+        * examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp:
+        * examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp:
+
+          Added event filtering, correlation, and CosNotification service.
+
 Tue Sep 23 21:35:17 2003  George Edwards <g.edwards@vanderbilt.edu>
 
         * ciao/CIAO_Events.h:
diff --git a/TAO/CIAO/ciao/CIAO_Events.cpp b/TAO/CIAO/ciao/CIAO_Events.cpp
index a07ffddf954..1537a6de8c6 100644
--- a/TAO/CIAO/ciao/CIAO_Events.cpp
+++ b/TAO/CIAO/ciao/CIAO_Events.cpp
@@ -59,11 +59,12 @@ void CIAO_Events::RTEventService::connect_event_supplier (
     supplier_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
+  RtecEventChannelAdmin::SupplierQOS_var qos = supplier_config->get_rt_event_qos (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
   this->proxy_consumer_->connect_push_supplier (this->push_supplier_.in (),
-                                                *supplier_config->get_rt_event_qos (ACE_ENV_SINGLE_ARG_PARAMETER)
+                                                qos.in ()
                                                 ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
-
 }
 
 /// Connect a consumer to the RT event channel.
@@ -99,12 +100,14 @@ CIAO_Events::EventServiceInfo CIAO_Events::RTEventService::connect_event_consume
     consumer_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
 
+  RtecEventChannelAdmin::ConsumerQOS_var qos = consumer_config->get_rt_event_qos (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
   proxy_supplier->connect_push_consumer (push_consumer.in (),
-                                         *consumer_config->get_rt_event_qos (ACE_ENV_SINGLE_ARG_PARAMETER)
+                                         qos.in ()
                                          ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
-  service_info.connection.push_consumer = push_consumer._retn ();
+  service_info.disconnect.rtec_push_consumer = push_consumer._retn ();
 
   return service_info;
 }
@@ -117,7 +120,7 @@ void CIAO_Events::RTEventService::disconnect_event_consumer (
     Components::InvalidName,
     Components::InvalidConnection))
 {
-  service_info.connection.push_consumer->disconnect_push_consumer (
+  service_info.disconnect.rtec_push_consumer->disconnect_push_consumer (
     ACE_ENV_SINGLE_ARG_PARAMETER);
 	ACE_CHECK;
 }
@@ -147,7 +150,6 @@ void CIAO_Events::RTEventService::push_event (
   events[0].header.source = this->source_id_;
   events[0].header.type = this->type_id_;
   events[0].data.any_value <<= ev;
-  ev->_add_ref ();
 
   this->proxy_consumer_->push (events ACE_ENV_ARG_PARAMETER);
 	ACE_CHECK;
@@ -170,14 +172,14 @@ CIAO_Events::EventServiceInfo CIAO_Events::DirectEventService::connect_event_con
         CORBA::SystemException))
 {
   CIAO_Events::EventServiceInfo service_info;
-  service_info.type = RTEC;
+  service_info.type = DIRECT;
   service_info.service = this;
 
-  ACE_NEW_RETURN (service_info.connection.consumer_key, ACE_Active_Map_Manager_Key, service_info);
+  ACE_NEW_RETURN (service_info.disconnect.consumer_key, ACE_Active_Map_Manager_Key, service_info);
   Components::EventConsumerBase_var consumer =
     consumer_config->get_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
-  this->consumer_map_.bind (consumer._retn (), *service_info.connection.consumer_key);
+  this->consumer_map_.bind (consumer._retn (), *service_info.disconnect.consumer_key);
 
   return service_info;
 
@@ -230,28 +232,218 @@ void CIAO_Events::DirectEventService::push_event (
     }
 }
 
+CIAO_Events::CosNotifyService::CosNotifyService (CORBA::ORB_ptr orb, CosNotifyChannelAdmin::EventChannel_ptr ec) :
+  orb_ (CORBA::ORB::_duplicate (orb)),
+  notify_channel_ (CosNotifyChannelAdmin::EventChannel::_duplicate (ec)),
+  type_id_ ("Any"),
+  source_id_ ("Any")
+{
+  CORBA::Object_var poa_object =
+    orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+  if (CORBA::is_nil (poa_object.in ()))
+    ACE_ERROR ((LM_ERROR,
+                " (%P|%t) Unable to initialize the POA.\n"));
+  this->root_poa_ =
+    PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+void CIAO_Events::CosNotifyService::connect_event_supplier (
+        CIAO_Events::Supplier_Config_ptr supplier_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::CosNotifyService::connect_event_supplie\n"));
+
+  CosNotifyChannelAdmin::AdminID admin_id;
+  CosNotifyChannelAdmin::SupplierAdmin_var supplier_admin =
+    this->notify_channel_->new_for_suppliers (CosNotifyChannelAdmin::OR_OP,
+                                              admin_id
+                                              ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyChannelAdmin::ProxyID proxy_id;
+  CosNotifyChannelAdmin::ProxyConsumer_var my_proxy =
+    supplier_admin->obtain_notification_push_consumer (CosNotifyChannelAdmin::STRUCTURED_EVENT,
+                                                       proxy_id
+                                                       ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->proxy_consumer_ = CosNotifyChannelAdmin::StructuredProxyPushConsumer::_narrow (my_proxy.in ());
+  if (CORBA::is_nil (this->proxy_consumer_.in ()))
+    {
+      ACE_ERROR ((LM_ERROR,
+                " (%P|%t) CIAO_Events::CosNotifyService::connect_event_supplier\n"));
+    }
+
+  // Create and register supplier servant
+  CIAO_Events::CosNotifyServiceSupplier_impl * supplier_servant;
+  ACE_NEW (supplier_servant,
+           CIAO_Events::CosNotifyServiceSupplier_impl (orb_.in ()));
+  this->push_supplier_ =
+    supplier_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyFilter::Filter_var filter = supplier_config->get_notify_filter (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotification::QoSProperties_var qos = supplier_config->get_notify_qos (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->proxy_consumer_->add_filter (filter.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->proxy_consumer_->set_qos (qos.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->proxy_consumer_->connect_structured_push_supplier (this->push_supplier_.in ()
+                                                           ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+CIAO_Events::EventServiceInfo CIAO_Events::CosNotifyService::connect_event_consumer (
+        CIAO_Events::Consumer_Config_ptr consumer_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  CIAO_Events::EventServiceInfo service_info;
+  service_info.type = NOTIFY;
+  service_info.service = this;
+
+  Components::EventConsumerBase_var consumer =
+    consumer_config->get_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyChannelAdmin::AdminID admin_id;
+  CosNotifyChannelAdmin::ConsumerAdmin_var consumer_admin =
+    this->notify_channel_->new_for_consumers (CosNotifyChannelAdmin::OR_OP,
+                                              admin_id
+                                              ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyChannelAdmin::ProxyID proxy_id;
+  CosNotifyChannelAdmin::ProxySupplier_var my_proxy =
+    consumer_admin->obtain_notification_push_supplier (CosNotifyChannelAdmin::STRUCTURED_EVENT,
+                                                       proxy_id
+                                                       ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyChannelAdmin::StructuredProxyPushSupplier_var proxy_supplier =
+    CosNotifyChannelAdmin::StructuredProxyPushSupplier::_narrow (my_proxy.in ());
+  if (CORBA::is_nil (proxy_supplier.in ()))
+    {
+      ACE_ERROR ((LM_ERROR,
+                " (%P|%t) CIAO_Events::CosNotifyService::connect_event_consumer\n"));
+    }
+
+  // Create and register consumer servant
+  CIAO_Events::CosNotifyServiceConsumer_impl * consumer_servant;
+  ACE_NEW_RETURN (consumer_servant,
+                  CIAO_Events::CosNotifyServiceConsumer_impl (orb_.in (), consumer.in ()),
+                  service_info);
+  CosNotifyComm::StructuredPushConsumer_var push_consumer =
+    consumer_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotifyFilter::Filter_var filter = consumer_config->get_notify_filter (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  CosNotification::QoSProperties_var qos = consumer_config->get_notify_qos (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  proxy_supplier->add_filter (filter.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  proxy_supplier->set_qos (qos.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  proxy_supplier->connect_structured_push_consumer (push_consumer.in ()
+                                                    ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  service_info.disconnect.notify_push_consumer = push_consumer._retn ();
+  return service_info;
+
+}
+
+void CIAO_Events::CosNotifyService::disconnect_event_consumer (
+        CIAO_Events::EventServiceInfo service_info
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection))
+{
+}
+
+void CIAO_Events::CosNotifyService::disconnect_event_supplier (
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection))
+{
+}
+
+void CIAO_Events::CosNotifyService::push_event (
+        Components::EventBase *ev
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::DirectEventService::push_event\n"));
+  CosNotification::StructuredEvent event;
+  event.header.fixed_header.event_type.domain_name = CORBA::string_dup ("CIAO_Events");
+  event.header.fixed_header.event_type.type_name = this->type_id_;
+  event.header.fixed_header.event_name = this->source_id_;
+  event.remainder_of_body <<= ev;
+  ev->_add_ref ();
+
+  this->proxy_consumer_->push_structured_event (event ACE_ENV_ARG_PARAMETER);
+	ACE_CHECK;
+
+}
+
 CIAO_Events::RTEvent_Consumer_Config::RTEvent_Consumer_Config (Events_Manager * em) :
   service_type_ (RTEC),
   events_manager_ (em)
 {
 }
 
+void CIAO_Events::RTEvent_Consumer_Config::start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->qos_.start_conjunction_group (size);
+}
+
+void CIAO_Events::RTEvent_Consumer_Config::start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->qos_.start_disjunction_group (size);
+}
+
 void CIAO_Events::RTEvent_Consumer_Config::set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->consumer_id_ = connection_id;
 }
 
-void CIAO_Events::RTEvent_Consumer_Config::set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+void CIAO_Events::RTEvent_Consumer_Config::insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->supplier_id_ = connection_id;
+  this->qos_.insert (this->events_manager_->get_rtec_source_id (connection_id),
+                    this->events_manager_->get_rtec_type_id (connection_id),
+                    0);
 }
 
 void CIAO_Events::RTEvent_Consumer_Config::set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  this->consumer_ = consumer;
+  this->consumer_ = Components::EventConsumerBase::_duplicate (consumer);
 }
 
 CIAO_Events::CONNECTION_ID CIAO_Events::RTEvent_Consumer_Config::get_consumer_id (ACE_ENV_SINGLE_ARG_DECL)
@@ -275,7 +467,7 @@ CIAO_Events::EventServiceType CIAO_Events::RTEvent_Consumer_Config::get_service_
 Components::EventConsumerBase_ptr CIAO_Events::RTEvent_Consumer_Config::get_consumer (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  return this->consumer_;
+  return this->consumer_._retn ();
 }
 
 RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::RTEvent_Consumer_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
@@ -283,14 +475,21 @@ RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::RTEvent_Consumer_Config::get_r
 {
   ACE_DEBUG ((LM_DEBUG, "CIAO_Events::RTEvent_Consumer_Config::get_rt_event_qos\n"));
 
-  ACE_ConsumerQOS_Factory qos;
-  qos.start_logical_and_group (2);
-  qos.insert_type (this->events_manager_->get_rtec_type_id (this->supplier_id_),
-                   0);
-  qos.insert_source (this->events_manager_->get_rtec_source_id (this->supplier_id_),
-                     0);
+  RtecEventChannelAdmin::ConsumerQOS * consumer_qos = 0;
+  ACE_NEW_RETURN (consumer_qos, RtecEventChannelAdmin::ConsumerQOS (this->qos_.get_ConsumerQOS ()), 0);
+  return consumer_qos;
+}
+
+CosNotifyFilter::Filter * CIAO_Events::RTEvent_Consumer_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
 
-  return (RtecEventChannelAdmin::ConsumerQOS *) &qos.get_ConsumerQOS ();
+CosNotification::QoSProperties * CIAO_Events::RTEvent_Consumer_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
 }
 
 CIAO_Events::RTEvent_Supplier_Config::RTEvent_Supplier_Config (Events_Manager * em) :
@@ -303,6 +502,10 @@ void CIAO_Events::RTEvent_Supplier_Config::set_supplier_id (CONNECTION_ID connec
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->supplier_id_ = connection_id;
+  this->qos_.insert (this->events_manager_->get_rtec_source_id (this->supplier_id_),
+                     this->events_manager_->get_rtec_type_id (this->supplier_id_),
+                     0,
+                     1);
 }
 
 CIAO_Events::CONNECTION_ID CIAO_Events::RTEvent_Supplier_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
@@ -322,14 +525,22 @@ RtecEventChannelAdmin::SupplierQOS * CIAO_Events::RTEvent_Supplier_Config::get_r
 {
 
   ACE_DEBUG ((LM_DEBUG, "CIAO_Events::RTEvent_Supplier_Config::get_rt_event_qos\n"));
+  
+  RtecEventChannelAdmin::SupplierQOS * supplier_qos = 0;
+  ACE_NEW_RETURN (supplier_qos, RtecEventChannelAdmin::SupplierQOS (this->qos_.get_SupplierQOS ()), 0);
+  return supplier_qos;
+}
 
-  ACE_SupplierQOS_Factory qos;
-  qos.insert (this->events_manager_->get_rtec_type_id (this->supplier_id_),
-              this->events_manager_->get_rtec_source_id (this->supplier_id_),
-              0,
-              1);
+CosNotification::QoSProperties * CIAO_Events::RTEvent_Supplier_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
 
-  return (RtecEventChannelAdmin::SupplierQOS *) &qos.get_SupplierQOS ();
+CosNotifyFilter::Filter * CIAO_Events::RTEvent_Supplier_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
 }
 
 CIAO_Events::Direct_Consumer_Config::Direct_Consumer_Config (Events_Manager * em) :
@@ -338,13 +549,23 @@ CIAO_Events::Direct_Consumer_Config::Direct_Consumer_Config (Events_Manager * em
 {
 }
 
+void CIAO_Events::Direct_Consumer_Config::start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void CIAO_Events::Direct_Consumer_Config::start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
 void CIAO_Events::Direct_Consumer_Config::set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->consumer_id_ = connection_id;
 }
 
-void CIAO_Events::Direct_Consumer_Config::set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+void CIAO_Events::Direct_Consumer_Config::insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
   this->supplier_id_ = connection_id;
@@ -353,7 +574,7 @@ void CIAO_Events::Direct_Consumer_Config::set_supplier_id (CONNECTION_ID connect
 void CIAO_Events::Direct_Consumer_Config::set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  this->consumer_ = consumer;
+  this->consumer_ = Components::EventConsumerBase::_duplicate (consumer);
 }
 
 CIAO_Events::CONNECTION_ID CIAO_Events::Direct_Consumer_Config::get_consumer_id (ACE_ENV_SINGLE_ARG_DECL)
@@ -377,7 +598,7 @@ CIAO_Events::EventServiceType CIAO_Events::Direct_Consumer_Config::get_service_t
 Components::EventConsumerBase_ptr CIAO_Events::Direct_Consumer_Config::get_consumer (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException))
 {
-  return this->consumer_;
+  return this->consumer_._retn ();
 }
 
 RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::Direct_Consumer_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
@@ -386,6 +607,18 @@ RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::Direct_Consumer_Config::get_rt
   return 0;
 }
 
+CosNotifyFilter::Filter * CIAO_Events::Direct_Consumer_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CosNotification::QoSProperties * CIAO_Events::Direct_Consumer_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
 CIAO_Events::Direct_Supplier_Config::Direct_Supplier_Config (Events_Manager * em) :
   service_type_ (DIRECT),
   events_manager_ (em)
@@ -416,10 +649,141 @@ RtecEventChannelAdmin::SupplierQOS * CIAO_Events::Direct_Supplier_Config::get_rt
   return 0;
 }
 
+CosNotifyFilter::Filter * CIAO_Events::Direct_Supplier_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CosNotification::QoSProperties * CIAO_Events::Direct_Supplier_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CIAO_Events::CosNotify_Consumer_Config::CosNotify_Consumer_Config (Events_Manager * em) :
+  service_type_ (NOTIFY),
+  events_manager_ (em)
+{
+}
+
+void CIAO_Events::CosNotify_Consumer_Config::start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void CIAO_Events::CosNotify_Consumer_Config::start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void CIAO_Events::CosNotify_Consumer_Config::set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->consumer_id_ = connection_id;
+}
+
+void CIAO_Events::CosNotify_Consumer_Config::insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->supplier_id_ = connection_id;
+}
+
+void CIAO_Events::CosNotify_Consumer_Config::set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->consumer_ = Components::EventConsumerBase::_duplicate (consumer);
+}
+
+CIAO_Events::CONNECTION_ID CIAO_Events::CosNotify_Consumer_Config::get_consumer_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->consumer_id_;
+}
+
+CIAO_Events::CONNECTION_ID CIAO_Events::CosNotify_Consumer_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::CosNotify_Consumer_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+Components::EventConsumerBase_ptr CIAO_Events::CosNotify_Consumer_Config::get_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->consumer_._retn ();
+}
+
+RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::CosNotify_Consumer_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CosNotifyFilter::Filter * CIAO_Events::CosNotify_Consumer_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->filter_._retn ();
+}
+
+CosNotification::QoSProperties * CIAO_Events::CosNotify_Consumer_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->qos_._retn ();
+}
+
+CIAO_Events::CosNotify_Supplier_Config::CosNotify_Supplier_Config (Events_Manager * em) :
+  service_type_ (NOTIFY),
+  events_manager_ (em)
+{
+}
+
+void CIAO_Events::CosNotify_Supplier_Config::set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->supplier_id_ = connection_id;
+}
+
+CIAO_Events::CONNECTION_ID CIAO_Events::CosNotify_Supplier_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::CosNotify_Supplier_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+RtecEventChannelAdmin::SupplierQOS * CIAO_Events::CosNotify_Supplier_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CosNotifyFilter::Filter * CIAO_Events::CosNotify_Supplier_Config::get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->filter_._retn ();
+}
+
+CosNotification::QoSProperties * CIAO_Events::CosNotify_Supplier_Config::get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->qos_._retn ();
+}
+
 /// Initialize the Events_Manager
 CIAO_Events::Events_Manager::Events_Manager (CORBA::ORB_ptr orb) :
   orb_ (CORBA::ORB::_duplicate (orb)),
-  rt_event_channel_ (RtecEventChannelAdmin::EventChannel::_nil ())
+  rt_event_channel_ (RtecEventChannelAdmin::EventChannel::_nil ()),
+  notify_channel_ (CosNotifyChannelAdmin::EventChannel::_nil ())
 {
   CORBA::Object_var poa_object =
     orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER);
@@ -452,38 +816,17 @@ CIAO_Events::Consumer_Config_ptr CIAO_Events::Events_Manager::create_consumer_co
     ACE_CHECK;
     return return_config._retn ();
   }
-
-  return 0;
-
-  /*
-  else if (ACE_OS::strcmp (service_name, "NS") == 0)
+  else if (ACE_OS::strcmp (service_type, "NOTIFY") == 0)
   {
-    service_info.type = NS;
-    if (this->notify_service_ == 0)
-      {
-        ACE_NEW_RETURN (this->notify_service_, CIAO_NotificationService, 0);
-      }
-    service_info.service = this->notify_service_;
-  }
-  else if (ACE_OS::strcmp (service_name, "RTNS") == 0)
-  {
-    service_info.type = RTNS;
-    if (this->rt_notify_service_ == 0)
-      {
-        ACE_NEW_RETURN (this->rt_notify_service_, CIAO_RTNotificationService, 0);
-      }
-    service_info.service = this->rt_notify_service_;
-  }
-  else if (ACE_OS::strcmp (service_name, "DIRECT") == 0)
-  {
-    service_info.type = DIRECT;
-    if (this->direct_event_service_ == 0)
-      {
-        ACE_NEW_RETURN (this->direct_event_service_, CIAO_DirectEventService, 0);
-      }
-    service_info.service = this->direct_event_service_;
+    CIAO_Events::CosNotify_Consumer_Config * consumer_config = 0;
+    ACE_NEW_RETURN (consumer_config, CIAO_Events::CosNotify_Consumer_Config (this), 0);
+    CIAO_Events::Consumer_Config_var return_config =
+      consumer_config->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+    ACE_CHECK;
+    return return_config._retn ();
   }
-  */
+
+  return 0;
 
 }
 
@@ -492,7 +835,7 @@ CIAO_Events::Supplier_Config_ptr CIAO_Events::Events_Manager::create_supplier_co
 
   if (ACE_OS::strcmp (service_type, "DIRECT") == 0)
   {
-    CIAO_Events::Direct_Supplier_Config * supplier_config;
+    CIAO_Events::Direct_Supplier_Config * supplier_config = 0;
     ACE_NEW_RETURN (supplier_config, CIAO_Events::Direct_Supplier_Config (this), 0);
     CIAO_Events::Supplier_Config_var return_config =
       supplier_config->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
@@ -501,13 +844,22 @@ CIAO_Events::Supplier_Config_ptr CIAO_Events::Events_Manager::create_supplier_co
   }
   else if (ACE_OS::strcmp (service_type, "RTEC") == 0)
   {
-    CIAO_Events::RTEvent_Supplier_Config * supplier_config;
+    CIAO_Events::RTEvent_Supplier_Config * supplier_config = 0;
     ACE_NEW_RETURN (supplier_config, CIAO_Events::RTEvent_Supplier_Config (this), 0);
     CIAO_Events::Supplier_Config_var return_config =
       supplier_config->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
     ACE_CHECK;
     return return_config._retn ();
   }
+  else if (ACE_OS::strcmp (service_type, "NOTIFY") == 0)
+  {
+    CIAO_Events::CosNotify_Supplier_Config * supplier_config = 0;
+    ACE_NEW_RETURN (supplier_config, CIAO_Events::CosNotify_Supplier_Config (this), 0);
+    CIAO_Events::Supplier_Config_var return_config =
+      supplier_config->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+    ACE_CHECK;
+    return return_config._retn ();
+  }
 
   return 0;
 }
@@ -532,6 +884,14 @@ CIAO_Events::EventServiceBase * CIAO_Events::Events_Manager::create_supplier (Su
       }
     ACE_NEW_RETURN (event_service, CIAO_Events::RTEventService (orb_.in (), rt_event_channel_.in ()), 0);
     break;
+  case NOTIFY:
+    if (CORBA::is_nil (this->notify_channel_.in ()))
+      {
+        this->create_notify_channel (ACE_ENV_SINGLE_ARG_DECL);
+        ACE_CHECK;
+      }
+    ACE_NEW_RETURN (event_service, CIAO_Events::CosNotifyService (orb_.in (), notify_channel_.in ()), 0);
+    break;
   }
 
   return event_service;
@@ -584,6 +944,25 @@ void CIAO_Events::Events_Manager::create_rt_event_channel (
   ACE_CHECK;
 }
 
+void CIAO_Events::Events_Manager::create_notify_channel (
+    ACE_ENV_SINGLE_ARG_DECL)
+  ACE_THROW_SPEC ((
+    CORBA::SystemException))
+{
+
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::Events_Manager::create_notify_channel\n"));
+
+  CosNotifyChannelAdmin::EventChannelFactory_var notify_factory;
+  CosNotifyChannelAdmin::ChannelID id;
+  CosNotification::QoSProperties initial_qos;
+  CosNotification::AdminProperties initial_admin;
+  this->notify_channel_ = notify_factory->create_channel (initial_qos,
+                                                          initial_admin,
+                                                          id
+                                                          ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
 CIAO_Events::RTEventServiceSupplier_impl::RTEventServiceSupplier_impl (void)
 {
 }
@@ -605,6 +984,7 @@ void CIAO_Events::RTEventServiceSupplier_impl::disconnect_push_supplier (void)
     ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
   PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
   root_poa->deactivate_object (oid);
+  delete this;
 }
 
 CIAO_Events::RTEventServiceConsumer_impl::RTEventServiceConsumer_impl (void)
@@ -627,9 +1007,9 @@ void CIAO_Events::RTEventServiceConsumer_impl::push (const RtecEventComm::EventS
       ::Components::EventBase * ev;
       if (events[i].data.any_value >>= ev)
         {
+          ev->_add_ref ();
           this->event_consumer_->push_event (ev
                                              ACE_ENV_ARG_PARAMETER);
-          ACE_CHECK;
         }
     }
 }
@@ -649,4 +1029,59 @@ void CIAO_Events::RTEventServiceConsumer_impl::disconnect_push_consumer (void)
     ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
   PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
   root_poa->deactivate_object (oid);
+  delete this;
+}
+
+CIAO_Events::CosNotifyServiceSupplier_impl::CosNotifyServiceSupplier_impl (void)
+{
+}
+
+CIAO_Events::CosNotifyServiceSupplier_impl::CosNotifyServiceSupplier_impl (CORBA::ORB_ptr orb) :
+  orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+
+void CIAO_Events::CosNotifyServiceSupplier_impl::disconnect_structured_push_supplier (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void CIAO_Events::CosNotifyServiceSupplier_impl::subscription_change (
+        const CosNotification::EventTypeSeq& events_added,
+        const CosNotification::EventTypeSeq& events_removed
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        CosNotifyComm::InvalidEventType))
+{
+}
+
+CIAO_Events::CosNotifyServiceConsumer_impl::CosNotifyServiceConsumer_impl (void)
+{
+}
+
+CIAO_Events::CosNotifyServiceConsumer_impl::CosNotifyServiceConsumer_impl (CORBA::ORB_ptr orb,
+                                                                           Components::EventConsumerBase_ptr consumer) :
+    orb_ (CORBA::ORB::_duplicate (orb)),
+    event_consumer_ (Components::EventConsumerBase::_duplicate (consumer))
+{
+}
+
+void CIAO_Events::CosNotifyServiceConsumer_impl::push_structured_event (const CosNotification::StructuredEvent& event)
+{
+}
+
+void CIAO_Events::CosNotifyServiceConsumer_impl::disconnect_structured_push_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+}
+
+void CIAO_Events::CosNotifyServiceConsumer_impl::offer_change (
+        const CosNotification::EventTypeSeq& events_added,
+        const CosNotification::EventTypeSeq& events_removed
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        CosNotifyComm::InvalidEventType))
+{
 }
diff --git a/TAO/CIAO/ciao/CIAO_Events.h b/TAO/CIAO/ciao/CIAO_Events.h
index 7e224aa2eae..e56379bdfbd 100644
--- a/TAO/CIAO/ciao/CIAO_Events.h
+++ b/TAO/CIAO/ciao/CIAO_Events.h
@@ -16,6 +16,8 @@
 #define CIAO_EVENTS_H
 #include /**/ "ace/pre.h"
 
+#include "orbsvcs/CosNotifyCommS.h"
+#include "orbsvcs/CosNotifyChannelAdminS.h"
 #include "orbsvcs/RtecEventCommS.h"
 #include "orbsvcs/RtecEventChannelAdminS.h"
 #include "Event_Utilities.h"
@@ -39,9 +41,10 @@ namespace CIAO_Events
     EventServiceBase * service;
     union
       {
-        RtecEventComm::PushConsumer_ptr push_consumer;
+        CosNotifyComm::StructuredPushConsumer_ptr notify_push_consumer;
+        RtecEventComm::PushConsumer_ptr rtec_push_consumer;
         ACE_Active_Map_Manager_Key * consumer_key;
-      } connection;
+      } disconnect;
   };
 
   /// An abstract base class. Derived classes will provide appropriate implementations of
@@ -196,6 +199,67 @@ namespace CIAO_Events
     
   };
 
+  class CosNotifyService :
+    public virtual EventServiceBase
+  {
+
+  public:
+
+    CosNotifyService (CORBA::ORB_ptr orb, CosNotifyChannelAdmin::EventChannel_ptr ec);
+
+    virtual void connect_event_supplier (
+        CIAO_Events::Supplier_Config_ptr supplier_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException));
+
+    virtual CIAO_Events::EventServiceInfo connect_event_consumer (
+        CIAO_Events::Consumer_Config_ptr consumer_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException));
+
+    virtual void disconnect_event_consumer (
+        CIAO_Events::EventServiceInfo service_info
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection));
+
+    virtual void disconnect_event_supplier (
+        ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection));
+
+    virtual void push_event (
+        Components::EventBase *ev
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException));
+
+  private:
+
+    CORBA::ORB_var orb_;
+
+    // Reference to the Root POA
+    PortableServer::POA_var root_poa_;
+
+    /// Reference to the RT event channel
+    CosNotifyChannelAdmin::EventChannel_var notify_channel_;
+
+    /// The type of event
+    CORBA::String_var type_id_;
+
+    /// Info for the event publisher
+    CORBA::String_var source_id_;
+    CosNotifyComm::StructuredPushSupplier_var push_supplier_;
+    CosNotifyChannelAdmin::StructuredProxyPushConsumer_var proxy_consumer_;
+
+  };
+
   /// An implementation of the Consumer_Config IDL interface that configures
   /// an RT Event Channel. An object of this type will be returned from
   /// CIAO::Container::_ciao_create_event_consumer_config () when "RTEC" is
@@ -208,10 +272,16 @@ namespace CIAO_Events
 
     RTEvent_Consumer_Config (Events_Manager * em);
 
+    void start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
     void set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
-    void set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+    void insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
     void set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
@@ -232,17 +302,25 @@ namespace CIAO_Events
     RtecEventChannelAdmin::ConsumerQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
   private:
 
     CONNECTION_ID consumer_id_;
-    
-    CONNECTION_ID supplier_id_;
 
-    Components::EventConsumerBase_ptr consumer_;
+    CONNECTION_ID supplier_id_;
+    
+    Components::EventConsumerBase_var consumer_;
 
     EventServiceType service_type_;
 
     Events_Manager * events_manager_;
+
+    ACE_ConsumerQOS_Factory qos_;
   };
 
   /// An implementation of the Supplier_Config IDL interface that configures
@@ -269,6 +347,12 @@ namespace CIAO_Events
     RtecEventChannelAdmin::SupplierQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
   private:
 
     CONNECTION_ID supplier_id_;
@@ -276,6 +360,9 @@ namespace CIAO_Events
     EventServiceType service_type_;
 
     Events_Manager * events_manager_;
+
+    ACE_SupplierQOS_Factory qos_;
+
   };
 
   /// An implementation of the Consumer_Config IDL interface that configures
@@ -290,10 +377,16 @@ namespace CIAO_Events
 
     Direct_Consumer_Config (Events_Manager * em);
 
+    void start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
     void set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
-    void set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+    void insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
     void set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
@@ -314,13 +407,19 @@ namespace CIAO_Events
     RtecEventChannelAdmin::ConsumerQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
   private:
 
     CONNECTION_ID consumer_id_;
     
     CONNECTION_ID supplier_id_;
 
-    Components::EventConsumerBase_ptr consumer_;
+    Components::EventConsumerBase_var consumer_;
 
     EventServiceType service_type_;
 
@@ -351,6 +450,116 @@ namespace CIAO_Events
     RtecEventChannelAdmin::SupplierQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
 
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+  private:
+
+    CONNECTION_ID supplier_id_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
+  };
+
+  /// An implementation of the Consumer_Config IDL interface that configures
+  /// the CosNotify service. An object of this type will be returned from
+  /// CIAO::Container::_ciao_create_event_consumer_config () when "NOTIFY" is
+  /// specified as the event service type.
+  class CosNotify_Consumer_Config :
+    public virtual POA_CIAO_Events::Consumer_Config
+  {
+
+  public:
+
+    CosNotify_Consumer_Config (Events_Manager * em);
+
+    void start_conjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void start_disjunction_group (CORBA::Long size ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void set_consumer_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void insert_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    void set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CONNECTION_ID get_consumer_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CONNECTION_ID get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    EventServiceType get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    Components::EventConsumerBase_ptr get_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    RtecEventChannelAdmin::ConsumerQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+  private:
+
+    CONNECTION_ID consumer_id_;
+    
+    CONNECTION_ID supplier_id_;
+
+    Components::EventConsumerBase_var consumer_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
+
+    CosNotifyFilter::Filter_var filter_;
+
+    CosNotification::QoSProperties_var qos_;
+  };
+
+  /// An implementation of the Supplier_Config IDL interface that configures
+  /// the CosNotify service. An object of this type will be returned from
+  /// CIAO::Container::_ciao_create_event_supplier_config () when "NOTIFY" is
+  /// specified as the event service type.
+  class CosNotify_Supplier_Config :
+    public virtual POA_CIAO_Events::Supplier_Config
+  {
+
+  public:
+
+    CosNotify_Supplier_Config (Events_Manager * em);
+
+    void set_supplier_id (CONNECTION_ID connection_id ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CONNECTION_ID get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    EventServiceType get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    RtecEventChannelAdmin::SupplierQOS * get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotifyFilter::Filter * get_notify_filter (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    CosNotification::QoSProperties * get_notify_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
   private:
 
     CONNECTION_ID supplier_id_;
@@ -358,6 +567,10 @@ namespace CIAO_Events
     EventServiceType service_type_;
 
     Events_Manager * events_manager_;
+
+    CosNotifyFilter::Filter_var filter_;
+
+    CosNotification::QoSProperties_var qos_;
   };
 
   /// A helper class that encapsulates management functions for CIAO::Container.
@@ -385,13 +598,21 @@ namespace CIAO_Events
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
+    void create_notify_channel (
+        ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException));
+
     CORBA::ORB_var orb_;
 
     PortableServer::POA_var root_poa_;
 
-    /// Reference to the RT event channel
+    /// Reference to the RT Event channel
     RtecEventChannelAdmin::EventChannel_var rt_event_channel_;
 
+    /// Reference to the Notification channel
+    CosNotifyChannelAdmin::EventChannel_var notify_channel_;
+
     /// Map of event type ids
     ACE_Hash_Map_Manager<CONNECTION_ID, RtecEventComm::EventType, ACE_Null_Mutex>
       event_types_map_;
@@ -442,6 +663,62 @@ namespace CIAO_Events
     Components::EventConsumerBase_var event_consumer_;
   };
 
+  /// An implementation for PushSupplier
+  class CosNotifyServiceSupplier_impl :
+    public virtual POA_CosNotifyComm::StructuredPushSupplier,
+    public virtual PortableServer::RefCountServantBase
+  {
+
+  public:
+    CosNotifyServiceSupplier_impl (void);
+
+    CosNotifyServiceSupplier_impl (CORBA::ORB_ptr orb);
+
+    virtual void disconnect_structured_push_supplier (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    virtual void subscription_change (
+        const CosNotification::EventTypeSeq& events_added,
+        const CosNotification::EventTypeSeq& events_removed
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        CosNotifyComm::InvalidEventType));
+
+  private:
+    CORBA::ORB_var orb_;
+  };
+
+  /// An implementation for PushConsumer
+  class CosNotifyServiceConsumer_impl :
+    public virtual POA_CosNotifyComm::StructuredPushConsumer,
+    public virtual PortableServer::RefCountServantBase
+  {
+
+  public:
+    CosNotifyServiceConsumer_impl (void);
+
+    CosNotifyServiceConsumer_impl (CORBA::ORB_ptr orb,
+      Components::EventConsumerBase_ptr consumer);
+
+    virtual void push_structured_event (const CosNotification::StructuredEvent& event);
+
+    virtual void disconnect_structured_push_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException));
+
+    virtual void offer_change (
+        const CosNotification::EventTypeSeq& events_added,
+        const CosNotification::EventTypeSeq& events_removed
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        CosNotifyComm::InvalidEventType));
+
+  private:
+    CORBA::ORB_var orb_;
+    Components::EventConsumerBase_var event_consumer_;
+  };
+
 }
 
 #include /**/ "ace/post.h"
diff --git a/TAO/CIAO/ciao/CIAO_Events.idl b/TAO/CIAO/ciao/CIAO_Events.idl
index 293b4941a07..f41d638a001 100644
--- a/TAO/CIAO/ciao/CIAO_Events.idl
+++ b/TAO/CIAO/ciao/CIAO_Events.idl
@@ -10,6 +10,7 @@
 
 #include "CCM_Event.idl"
 #include "RtecEventChannelAdmin.idl"
+#include "CosNotifyChannelAdmin.idl"
 
 module CIAO_Events
 {
@@ -21,8 +22,8 @@ module CIAO_Events
     DIRECT,
     EC,
     RTEC,
-    NS,
-    RTNS
+    NOTIFY,
+    RTNOTIFY
   };
 
   /// An object for setting consumer QoS requirements. This will be expanded to
@@ -32,12 +33,19 @@ module CIAO_Events
   /// CIAO::Container::_ciao_create_event_consumer_config ().
   interface Consumer_Config
   {
-    void set_consumer_id (in CONNECTION_ID connection_id);
 
-    void set_supplier_id (in CONNECTION_ID connection_id);
+    // Configuring methods.
+    void start_conjunction_group (in long size);
+
+    void start_disjunction_group (in long size);
+
+    void insert_supplier_id (in CONNECTION_ID connection_id);
+
+    void set_consumer_id (in CONNECTION_ID connection_id);
 
     void set_consumer (in Components::EventConsumerBase consumer);
 
+    // Access methods.
     CONNECTION_ID get_consumer_id ();
 
     CONNECTION_ID get_supplier_id ();
@@ -47,6 +55,10 @@ module CIAO_Events
     EventServiceType get_service_type ();
 
     RtecEventChannelAdmin::ConsumerQOS get_rt_event_qos ();
+
+    CosNotifyFilter::Filter get_notify_filter ();
+
+    CosNotification::QoSProperties get_notify_qos ();
   };
 
 
@@ -55,13 +67,20 @@ module CIAO_Events
   /// Created via CIAO::Container::_ciao_create_event_supplier_config ().
   interface Supplier_Config
   {
+
+    // Configuring methods.
     void set_supplier_id (in CONNECTION_ID connection_id);
 
+    // Access methods.
     CONNECTION_ID get_supplier_id ();
 
     EventServiceType get_service_type ();
 
     RtecEventChannelAdmin::SupplierQOS get_rt_event_qos ();
+
+    CosNotifyFilter::Filter get_notify_filter ();
+
+    CosNotification::QoSProperties get_notify_qos ();
   };
 
 };
diff --git a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp
index 0713f949d41..81828c1a704 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp
@@ -297,7 +297,11 @@ namespace CIAO_GLUE_BasicSP
     CIAO_Events::Consumer_Config_var consumer_config =
       this->container_->_ciao_create_event_consumer_config ("RTEC" ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
-    consumer_config->set_supplier_id (0301 ACE_ENV_ARG_PARAMETER);
+    consumer_config->start_conjunction_group (2 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->insert_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->insert_supplier_id (0301 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     consumer_config->set_consumer_id (0302 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
diff --git a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp
index 03650f68cb3..a38c2c19653 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp
@@ -241,15 +241,17 @@ namespace CIAO_GLUE_BasicSP
   {
 
     CIAO_Events::Supplier_Config_var supplier_config =
-      this->container_->_ciao_create_event_supplier_config ("DIRECT" ACE_ENV_ARG_PARAMETER);
+      this->container_->_ciao_create_event_supplier_config ("RTEC" ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     supplier_config->set_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     CIAO_Events::Consumer_Config_var consumer_config =
-      this->container_->_ciao_create_event_consumer_config ("DIRECT" ACE_ENV_ARG_PARAMETER);
+      this->container_->_ciao_create_event_consumer_config ("RTEC" ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
-    consumer_config->set_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
+    consumer_config->start_disjunction_group (1 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->insert_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     consumer_config->set_consumer_id (0202 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
diff --git a/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp b/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp
index 84a904d9ab4..bedc88636b3 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp
@@ -229,15 +229,17 @@ namespace CIAO_GLUE_BasicSP
   ::Components::ExceededConnectionLimit))
   {
     CIAO_Events::Supplier_Config_var supplier_config =
-      this->container_->_ciao_create_event_supplier_config ("RTEC" ACE_ENV_ARG_PARAMETER);
+      this->container_->_ciao_create_event_supplier_config ("DIRECT" ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     supplier_config->set_supplier_id (0101 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     CIAO_Events::Consumer_Config_var consumer_config =
-      this->container_->_ciao_create_event_consumer_config ("RTEC" ACE_ENV_ARG_PARAMETER);
+      this->container_->_ciao_create_event_consumer_config ("DIRECT" ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
-    consumer_config->set_supplier_id (0101 ACE_ENV_ARG_PARAMETER);
+    consumer_config->start_disjunction_group (1 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->insert_supplier_id (0101 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     consumer_config->set_consumer_id (0102 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;