ChangeLogTag: Mon Sep 22 20:52:02 2003 George Edwards <g.edwards@vanderbilt.edu>

12 files changed, 1235 insertions, 518 deletions

diff --git a/TAO/CIAO/ChangeLog_EC b/TAO/CIAO/ChangeLog_EC
index 3b9bef5fc72..bfb7f14faf0 100644
--- a/TAO/CIAO/ChangeLog_EC
+++ b/TAO/CIAO/ChangeLog_EC
@@ -1,3 +1,24 @@
+Mon Sep 22 20:52:02 2003  George Edwards <g.edwards@vanderbilt.edu>
+
+        Added files:
+        
+        * ciao/CIAO_Events.h:
+        * ciao/CIAO_Events.cpp:
+        * ciao/CIAO_Events.idl:
+
+        Modified files:
+
+        * ciao/Container_Base.cpp:
+        * ciao/Container_Base.h:
+        * ciao/Cookies.cpp:
+        * ciao/Cookies.h:
+        * examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp:
+        * examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp:
+        * examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp:
+        * examples/handcrafted/BasicSP_EC/EC/EC_svnt.h:
+
+          Refactored CIAO event services.
+
 Mon Sep 15 16:59:34 2003  George Edwards <g.edwards@vanderbilt.edu>
 
         * ciao/CCM_Deployment.idl ciao/Container_Base.cpp 
@@ -13,5 +34,5 @@ Mon Sep 15 16:59:34 2003  George Edwards <g.edwards@vanderbilt.edu>
         * examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp 
         * examples/handcrafted/BasicSP_EC/EC/EC_svnt.h
 
-        Initial implementation of CIAO event services.
+          Initial implementation of CIAO event services.
 
diff --git a/TAO/CIAO/ciao/CIAO_Events.cpp b/TAO/CIAO/ciao/CIAO_Events.cpp
index 7717ca08775..29c1c85ad91 100644
--- a/TAO/CIAO/ciao/CIAO_Events.cpp
+++ b/TAO/CIAO/ciao/CIAO_Events.cpp
@@ -12,58 +12,633 @@
  */
 //=============================================================================
 
-::Components::Cookie * CIAO::CIAO_RTEventService::specify_event_service (
-    const char * event_name,
-    const char * publisher_name,
-    const char * service_name
+#include "CIAO_Events.h"
+
+CIAO_Events::RTEventService::RTEventService (CORBA::ORB_ptr orb, RtecEventChannelAdmin::EventChannel_ptr ec) :
+  orb_ (CORBA::ORB::_duplicate (orb)),
+  rt_event_channel_ (RtecEventChannelAdmin::EventChannel::_duplicate (ec)),
+  type_id_ (ACE_ES_EVENT_ANY),
+  source_id_ (ACE_ES_EVENT_SOURCE_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::RTEventService::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::RTEventService::connect_event_supplier\n"));
+
+  RtecEventChannelAdmin::SupplierAdmin_var supplier_admin =
+    this->rt_event_channel_->for_suppliers (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->proxy_consumer_ =
+    supplier_admin->obtain_push_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  // Create and register supplier servant
+  CIAO_Events::RTEventServiceSupplier_impl * supplier_servant;
+  ACE_NEW (supplier_servant,
+           CIAO_Events::RTEventServiceSupplier_impl (orb_.in ()));
+  this->push_supplier_ =
+    supplier_servant->_this (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)
+                                                ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
 }
 
-::Components::Cookie * CIAO::CIAO_RTEventService::connect_event_supplier (
-    CIAO_EventServiceInfo service_info
+CIAO_Events::EventServiceInfo CIAO_Events::RTEventService::connect_event_consumer (
+    CIAO_Events::Consumer_Config_ptr consumer_config
     ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((
     CORBA::SystemException))
 {
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::RTEventService::connect_event_consumer\n"));
+
+  CIAO_Events::EventServiceInfo service_info;
+  service_info.type = RTEC;
+  service_info.service = this;
+
+  Components::EventConsumerBase_var consumer =
+    consumer_config->get_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
+    this->rt_event_channel_->for_consumers (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+  RtecEventChannelAdmin::ProxyPushSupplier_var proxy_supplier =
+    consumer_admin->obtain_push_supplier (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+
+  // Create and register consumer servant
+  CIAO_Events::RTEventServiceConsumer_impl * consumer_servant;
+  ACE_NEW_RETURN (consumer_servant,
+                  CIAO_Events::RTEventServiceConsumer_impl (orb_.in (), consumer.in ()),
+                  service_info);
+  RtecEventComm::PushConsumer_var push_consumer =
+    consumer_servant->_this (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)
+                                         ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  service_info.connection.push_consumer = push_consumer._retn ();
+
+  return service_info;
 }
 
-::Components::Cookie * CIAO::CIAO_RTEventService::connect_event_consumer (
-    ::Components::EventConsumerBase_ptr c,
-    CIAO_EventServiceInfo service_info
+void CIAO_Events::RTEventService::disconnect_event_consumer (
+    CIAO_Events::EventServiceInfo service_info
     ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((
-    CORBA::SystemException))
+    CORBA::SystemException,
+    Components::InvalidName,
+    Components::InvalidConnection))
 {
+  service_info.connection.push_consumer->disconnect_push_consumer (
+    ACE_ENV_SINGLE_ARG_PARAMETER);
+	ACE_CHECK;
 }
 
-void CIAO::CIAO_RTEventService::disconnect_event_consumer (
-    ::Components::Cookie *ck
-    ACE_ENV_ARG_DECL)
+void CIAO_Events::RTEventService::disconnect_event_supplier (
+    ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((
-    ::CORBA::SystemException,
-    ::Components::InvalidName,
-    ::Components::InvalidConnection))
+    CORBA::SystemException,
+    Components::InvalidName,
+    Components::InvalidConnection))
 {
+  this->push_supplier_->disconnect_push_supplier (
+    ACE_ENV_SINGLE_ARG_PARAMETER);
+	ACE_CHECK;
 }
 
-void CIAO::CIAO_RTEventService::disconnect_event_supplier (
-    ::Components::Cookie *ck
+void CIAO_Events::RTEventService::push_event (
+    ::Components::EventBase *ev
     ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((
-    ::CORBA::SystemException,
-    ::Components::InvalidName,
-    ::Components::InvalidConnection))
+    CORBA::SystemException))
 {
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::RTEventService::push_event\n"));
+
+  RtecEventComm::EventSet events (1);
+  events.length (1);
+  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;
 }
 
-void CIAO::CIAO_RTEventService::push_event (
-    ::Components::EventBase *ev,
-    ::Components::Cookie *ck
-    ACE_ENV_ARG_DECL)
+void CIAO_Events::DirectEventService::connect_event_supplier (
+        CIAO_Events::Supplier_Config_ptr supplier_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+}
+
+CIAO_Events::EventServiceInfo CIAO_Events::DirectEventService::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 = RTEC;
+  service_info.service = this;
+
+  ACE_NEW_RETURN (service_info.connection.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);
+
+  return service_info;
+
+}
+
+void CIAO_Events::DirectEventService::disconnect_event_consumer (
+        CIAO_Events::EventServiceInfo service_info
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection))
+{
+}
+
+void CIAO_Events::DirectEventService::disconnect_event_supplier (
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection))
+{
+}
+
+void CIAO_Events::DirectEventService::push_event (
+        Components::EventBase *ev
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::DirectEventService::push_event\n"));
+
+  ev->_add_ref ();
+
+  ACE_Active_Map_Manager<Components::EventConsumerBase_ptr>::iterator end =
+    this->consumer_map_.end ();
+
+  for (ACE_Active_Map_Manager<Components::EventConsumerBase_ptr>::iterator iter =
+    this->consumer_map_.begin ();
+    iter != end;
+    ++iter)
+    {
+      ACE_Active_Map_Manager<Components::EventConsumerBase_ptr>::ENTRY &entry = *iter;
+
+      entry.int_id_->push_event (
+        ev
+        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::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)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->supplier_id_ = connection_id;
+}
+
+void CIAO_Events::RTEvent_Consumer_Config::set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->consumer_ = consumer;
+}
+
+CIAO_Events::CONNECTION_ID CIAO_Events::RTEvent_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::RTEvent_Consumer_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::RTEvent_Consumer_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+Components::EventConsumerBase_ptr CIAO_Events::RTEvent_Consumer_Config::get_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->consumer_;
+}
+
+RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::RTEvent_Consumer_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  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);
+
+  return (RtecEventChannelAdmin::ConsumerQOS *) &qos.get_ConsumerQOS ();
+}
+
+CIAO_Events::RTEvent_Supplier_Config::RTEvent_Supplier_Config (Events_Manager * em) :
+  service_type_ (RTEC),
+  events_manager_ (em)
+{
+}
+
+void CIAO_Events::RTEvent_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::RTEvent_Supplier_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::RTEvent_Supplier_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+RtecEventChannelAdmin::SupplierQOS * CIAO_Events::RTEvent_Supplier_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::RTEvent_Supplier_Config::get_rt_event_qos\n"));
+
+  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);
+
+  return (RtecEventChannelAdmin::SupplierQOS *) &qos.get_SupplierQOS ();
+}
+
+CIAO_Events::Direct_Consumer_Config::Direct_Consumer_Config (Events_Manager * em) :
+  service_type_ (DIRECT),
+  events_manager_ (em)
+{
+}
+
+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)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->supplier_id_ = connection_id;
+}
+
+void CIAO_Events::Direct_Consumer_Config::set_consumer (Components::EventConsumerBase_ptr consumer ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  this->consumer_ = consumer;
+}
+
+CIAO_Events::CONNECTION_ID CIAO_Events::Direct_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::Direct_Consumer_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::Direct_Consumer_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+Components::EventConsumerBase_ptr CIAO_Events::Direct_Consumer_Config::get_consumer (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->consumer_;
+}
+
+RtecEventChannelAdmin::ConsumerQOS * CIAO_Events::Direct_Consumer_Config::get_rt_event_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)
+{
+}
+
+void CIAO_Events::Direct_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::Direct_Supplier_Config::get_supplier_id (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->supplier_id_;
+}
+
+CIAO_Events::EventServiceType CIAO_Events::Direct_Supplier_Config::get_service_type (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return this->service_type_;
+}
+
+RtecEventChannelAdmin::SupplierQOS * CIAO_Events::Direct_Supplier_Config::get_rt_event_qos (ACE_ENV_SINGLE_ARG_DECL)
+      ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  return 0;
+}
+
+CIAO_Events::Events_Manager::Events_Manager (CORBA::ORB_ptr orb) :
+  orb_ (CORBA::ORB::_duplicate (orb)),
+  rt_event_channel_ (RtecEventChannelAdmin::EventChannel::_nil ())
+{
+  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;
+}
+
+CIAO_Events::Consumer_Config_ptr CIAO_Events::Events_Manager::create_consumer_config (const char * service_type)
+{
+  if (ACE_OS::strcmp (service_type, "DIRECT") == 0)
+  {
+    CIAO_Events::Direct_Consumer_Config * consumer_config = 0;
+    ACE_NEW_RETURN (consumer_config, CIAO_Events::Direct_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 ();
+  }
+  else if (ACE_OS::strcmp (service_type, "RTEC") == 0)
+  {
+    CIAO_Events::RTEvent_Consumer_Config * consumer_config = 0;
+    ACE_NEW_RETURN (consumer_config, CIAO_Events::RTEvent_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;
+
+  /*
+  else if (ACE_OS::strcmp (service_name, "NS") == 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::Supplier_Config_ptr CIAO_Events::Events_Manager::create_supplier_config (const char * service_type)
+{
+
+  if (ACE_OS::strcmp (service_type, "DIRECT") == 0)
+  {
+    CIAO_Events::Direct_Supplier_Config * supplier_config;
+    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);
+    ACE_CHECK;
+    return return_config._retn ();
+  }
+  else if (ACE_OS::strcmp (service_type, "RTEC") == 0)
+  {
+    CIAO_Events::RTEvent_Supplier_Config * supplier_config;
+    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 ();
+  }
+
+  return 0;
+}
+
+CIAO_Events::EventServiceBase * CIAO_Events::Events_Manager::create_supplier (Supplier_Config_ptr supplier_config)
+{
+
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::Events_Manager::create_supplier\n"));
+
+  CIAO_Events::EventServiceBase * event_service = 0;
+
+  switch (supplier_config->get_service_type ())
+  {
+  case DIRECT:
+    ACE_NEW_RETURN (event_service, CIAO_Events::DirectEventService, 0);
+    break;
+  case RTEC:
+    if (CORBA::is_nil (this->rt_event_channel_.in ()))
+      {
+        this->create_rt_event_channel (ACE_ENV_SINGLE_ARG_DECL);
+        ACE_CHECK;
+      }
+    ACE_NEW_RETURN (event_service, CIAO_Events::RTEventService (orb_.in (), rt_event_channel_.in ()), 0);
+    break;
+  }
+
+  return event_service;
+}
+
+RtecEventComm::EventType CIAO_Events::Events_Manager::get_rtec_type_id (CONNECTION_ID connection_id)
+{
+
+  RtecEventComm::EventType event_type_id;
+
+  if (this->event_types_map_.find (connection_id, event_type_id) == -1)
+    {
+      event_type_id =
+        ACE_ES_EVENT_ANY + 1 + this->event_types_map_.current_size ();
+      this->event_types_map_.bind (connection_id, event_type_id);
+    }
+
+  return event_type_id;
+}
+
+RtecEventComm::EventSourceID CIAO_Events::Events_Manager::get_rtec_source_id (CONNECTION_ID connection_id)
+{
+
+  RtecEventComm::EventSourceID event_source_id;
+
+  if (this->publishers_map_.find (connection_id, event_source_id) == -1)
+    {
+      event_source_id =
+        ACE_ES_EVENT_SOURCE_ANY + 1 + this->publishers_map_.current_size ();
+      this->publishers_map_.bind (connection_id, event_source_id);
+    }
+
+  return event_source_id;
+}
+
+void CIAO_Events::Events_Manager::create_rt_event_channel (
+    ACE_ENV_SINGLE_ARG_DECL)
   ACE_THROW_SPEC ((
     CORBA::SystemException))
 {
+  ACE_DEBUG ((LM_DEBUG, "CIAO_Events::Events_Manager::create_rt_event_channel\n"));
+
+  TAO_EC_Event_Channel_Attributes attributes (this->root_poa_.in (),
+                                              this->root_poa_.in ());
+  TAO_EC_Event_Channel * ec_servant;
+  ACE_NEW (ec_servant, TAO_EC_Event_Channel (attributes));
+  ec_servant->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+  this->rt_event_channel_ = ec_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
+  ACE_CHECK;
+}
+
+CIAO_Events::RTEventServiceSupplier_impl::RTEventServiceSupplier_impl (void)
+{
+}
+
+CIAO_Events::RTEventServiceSupplier_impl::RTEventServiceSupplier_impl (CORBA::ORB_ptr orb) :
+  orb_ (CORBA::ORB::_duplicate (orb))
+{
+}
+  
+void CIAO_Events::RTEventServiceSupplier_impl::disconnect_push_supplier (void)
+{
+  CORBA::Object_var poa_object =
+    orb_->resolve_initial_references ("RootPOA" ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+  PortableServer::POA_var root_poa =
+    PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+  if (CORBA::is_nil (root_poa.in ()))
+    ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
+  PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
+  root_poa->deactivate_object (oid);
+}
+
+CIAO_Events::RTEventServiceConsumer_impl::RTEventServiceConsumer_impl (void)
+{
+}
+
+CIAO_Events::RTEventServiceConsumer_impl::RTEventServiceConsumer_impl
+  (CORBA::ORB_ptr orb,
+   Components::EventConsumerBase_ptr consumer) :
+    orb_ (CORBA::ORB::_duplicate (orb)),
+    event_consumer_ (Components::EventConsumerBase::_duplicate (consumer))
+{
+}
+
+void CIAO_Events::RTEventServiceConsumer_impl::push (const RtecEventComm::EventSet& events)
+{
+  ACE_DEBUG ((LM_DEBUG, "CIAO::RTEventServiceConsumer_impl::push\n"));
+  for (unsigned long i = 0; i < events.length (); ++i)
+    {
+      ::Components::EventBase * ev;
+      if (events[i].data.any_value >>= ev)
+        {
+          this->event_consumer_->push_event (ev
+                                             ACE_ENV_ARG_PARAMETER);
+          ACE_CHECK;
+        }
+    }
+}
+
+void CIAO_Events::RTEventServiceConsumer_impl::disconnect_push_consumer (void)
+  ACE_THROW_SPEC ((CORBA::SystemException))
+{
+  ACE_DEBUG ((LM_DEBUG, "CIAO::RTEventServiceConsumer_impl::disconnect_push_consumer\n"));
+
+  CORBA::Object_var poa_object =
+    orb_->resolve_initial_references ("RootPOA" ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+  PortableServer::POA_var root_poa =
+    PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+  if (CORBA::is_nil (root_poa.in ()))
+    ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
+  PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
+  root_poa->deactivate_object (oid);
 }
diff --git a/TAO/CIAO/ciao/CIAO_Events.h b/TAO/CIAO/ciao/CIAO_Events.h
index 689638add4b..621ad7e79ee 100644
--- a/TAO/CIAO/ciao/CIAO_Events.h
+++ b/TAO/CIAO/ciao/CIAO_Events.h
@@ -22,152 +22,371 @@
 #include "orbsvcs/Event/EC_Event_Channel.h"
 #include "orbsvcs/Event/EC_Default_Factory.h"
 #include "CCM_ContainerC.h"
+#include "ace/Active_Map_Manager.h"
+#include "CIAO_EventsS.h"
 
-namespace CIAO
+namespace CIAO_Events
 {
 
-  class CIAO_EventServiceBase
+  class EventServiceBase;
+  class Events_Manager;
+
+  struct EventServiceInfo
   {
+    EventServiceType type;
+    EventServiceBase * service;
+    union
+      {
+        RtecEventComm::PushConsumer_ptr push_consumer;
+        ACE_Active_Map_Manager_Key * consumer_key;
+      } connection;
+  };
 
-  public:
+  class EventServiceBase
+  {
 
-    virtual ::Components::Cookie * specify_event_service (
-        const char * event_name,
-        const char * publisher_name,
-        const char * service_name
-        ACE_ENV_ARG_DECL)
-      ACE_THROW_SPEC ((
-        CORBA::SystemException)) = 0;
+  public:
 
-    virtual ::Components::Cookie * connect_event_supplier (
-        ::CIAO::EventServiceInfo service_info
+    virtual void connect_event_supplier (
+        CIAO_Events::Supplier_Config_ptr supplier_config
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException)) = 0;
 
-    virtual ::Components::Cookie * connect_event_consumer (
-        ::Components::EventConsumerBase_ptr c,
-        ::CIAO::EventServiceInfo service_info
+    virtual CIAO_Events::EventServiceInfo connect_event_consumer (
+        CIAO_Events::Consumer_Config_ptr consumer_config
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException)) = 0;
 
     virtual void disconnect_event_consumer (
-        ::Components::Cookie *ck
+        CIAO_Events::EventServiceInfo service_info
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
-        ::CORBA::SystemException,
-        ::Components::InvalidName,
-        ::Components::InvalidConnection)) = 0;
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection)) = 0;
 
     virtual void disconnect_event_supplier (
-        ::Components::Cookie *ck
-        ACE_ENV_ARG_DECL)
+        ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((
-        ::CORBA::SystemException,
-        ::Components::InvalidName,
-        ::Components::InvalidConnection)) = 0;
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection)) = 0;
 
     virtual void push_event (
-        ::Components::EventBase *ev,
-        ::Components::Cookie *ck
+        Components::EventBase *ev
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException)) = 0;
 
   };
 
-  class CIAO_RTEventService :
-    public virtual CIAO_EventServiceBase
+  class RTEventService :
+    public virtual EventServiceBase
   {
 
   public:
 
-    virtual ::Components::Cookie * specify_event_service (
-        const char * event_name,
-        const char * publisher_name,
-        const char * service_name
+    RTEventService (CORBA::ORB_ptr orb, RtecEventChannelAdmin::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 ::Components::Cookie * connect_event_supplier (
-        CIAO_EventServiceInfo service_info
+    virtual CIAO_Events::EventServiceInfo connect_event_consumer (
+        CIAO_Events::Consumer_Config_ptr consumer_config
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
-    virtual ::Components::Cookie * connect_event_consumer (
-        ::Components::EventConsumerBase_ptr c,
-        CIAO_EventServiceInfo service_info
+    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
+    RtecEventChannelAdmin::EventChannel_var rt_event_channel_;
+
+    RtecEventComm::EventType type_id_;
+
+    RtecEventComm::EventSourceID source_id_;
+
+    RtecEventComm::PushSupplier_var push_supplier_;
+
+    RtecEventChannelAdmin::ProxyPushConsumer_var proxy_consumer_;
+
+  };
+
+  class DirectEventService :
+    public virtual EventServiceBase
+  {
+
+  public:
+
+    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 (
-        ::Components::Cookie *ck
+        CIAO_Events::EventServiceInfo service_info
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
-        ::CORBA::SystemException,
-        ::Components::InvalidName,
-        ::Components::InvalidConnection));
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection));
 
     virtual void disconnect_event_supplier (
-        ::Components::Cookie *ck
-        ACE_ENV_ARG_DECL)
+        ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((
-        ::CORBA::SystemException,
-        ::Components::InvalidName,
-        ::Components::InvalidConnection));
+        CORBA::SystemException,
+        Components::InvalidName,
+        Components::InvalidConnection));
 
     virtual void push_event (
-        ::Components::EventBase *ev,
-        ::Components::Cookie *ck
+        Components::EventBase *ev
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
   private:
 
-    /// Map of event types
-    ACE_Hash_Map_Manager<const char *, RtecEventComm::EventType, ACE_Null_Mutex>
-      ciao_event_types_map_;
+    /// Map of consumers
+    ACE_Active_Map_Manager<Components::EventConsumerBase_ptr> consumer_map_;
+    
+  };
 
-    /// Map of suppliers
-    ACE_Hash_Map_Manager<const char *, RtecEventComm::EventSourceID, ACE_Null_Mutex>
-      ciao_publishers_map_;
+  class RTEvent_Consumer_Config :
+    public virtual POA_CIAO_Events::Consumer_Config
+  {
 
-    /// Reference to the RT event channel
-    RtecEventChannelAdmin::EventChannel_var ciao_rt_event_channel_;
+  public:
+
+    RTEvent_Consumer_Config (Events_Manager * em);
+
+    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)
+      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));
+
+  private:
+
+    CONNECTION_ID consumer_id_;
+    
+    CONNECTION_ID supplier_id_;
+
+    Components::EventConsumerBase_ptr consumer_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
+  };
+
+  class RTEvent_Supplier_Config :
+    public virtual POA_CIAO_Events::Supplier_Config
+  {
+
+  public:
+
+    RTEvent_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));
+
+  private:
+
+    CONNECTION_ID supplier_id_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
   };
-      
 
-  enum CIAO_EventServiceType
+  class Direct_Consumer_Config :
+    public virtual POA_CIAO_Events::Consumer_Config
   {
-    DIRECT,
-    EC,
-    RTEC,
-    NS,
-    RTNS
+
+  public:
+
+    Direct_Consumer_Config (Events_Manager * em);
+
+    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)
+      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));
+
+  private:
+
+    CONNECTION_ID consumer_id_;
+    
+    CONNECTION_ID supplier_id_;
+
+    Components::EventConsumerBase_ptr consumer_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
   };
 
-  struct CIAO_EventServiceInfo
+  class Direct_Supplier_Config :
+    public virtual POA_CIAO_Events::Supplier_Config
   {
-    EventServiceType service_type;
-    RtecEventComm::EventType event_type_id;
-    RtecEventComm::EventSourceID event_source_id;
+
+  public:
+
+    Direct_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));
+
+  private:
+
+    CONNECTION_ID supplier_id_;
+
+    EventServiceType service_type_;
+
+    Events_Manager * events_manager_;
+  };
+
+  class Events_Manager
+  {
+
+  public:
+
+    Events_Manager (CORBA::ORB_ptr orb);
+
+    Consumer_Config_ptr create_consumer_config (const char * service_type);
+
+    Supplier_Config_ptr create_supplier_config (const char * service_type);
+
+    EventServiceBase * create_supplier (Supplier_Config * supplier_config);
+
+    RtecEventComm::EventType get_rtec_type_id (CONNECTION_ID connection_id);
+
+    RtecEventComm::EventSourceID get_rtec_source_id (CONNECTION_ID connection_id);
+
+  private:
+
+    void create_rt_event_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
+    RtecEventChannelAdmin::EventChannel_var rt_event_channel_;
+
+    /// Map of event type ids
+    ACE_Hash_Map_Manager<CONNECTION_ID, RtecEventComm::EventType, ACE_Null_Mutex>
+      event_types_map_;
+
+    /// Map of supplier ids
+    ACE_Hash_Map_Manager<CONNECTION_ID, RtecEventComm::EventSourceID, ACE_Null_Mutex>
+      publishers_map_;
+
   };
 
-  class CIAO_RTEventServiceSupplier_impl :
+  class RTEventServiceSupplier_impl :
     public virtual POA_RtecEventComm::PushSupplier,
     public virtual PortableServer::RefCountServantBase
   {
 
   public:
-    CIAO_RTEventServiceSupplier_impl (void);
+    RTEventServiceSupplier_impl (void);
 
-    CIAO_RTEventServiceSupplier_impl (CORBA::ORB_ptr orb);
+    RTEventServiceSupplier_impl (CORBA::ORB_ptr orb);
 
     virtual void disconnect_push_supplier (ACE_ENV_SINGLE_ARG_DECL)
       ACE_THROW_SPEC ((CORBA::SystemException));
@@ -176,15 +395,15 @@ namespace CIAO
     CORBA::ORB_var orb_;
   };
 
-  class CIAO_RTEventServiceConsumer_impl :
+  class RTEventServiceConsumer_impl :
     public virtual POA_RtecEventComm::PushConsumer,
     public virtual PortableServer::RefCountServantBase
   {
 
   public:
-    CIAO_RTEventServiceConsumer_impl (void);
+    RTEventServiceConsumer_impl (void);
 
-    CIAO_RTEventServiceConsumer_impl (CORBA::ORB_ptr orb,
+    RTEventServiceConsumer_impl (CORBA::ORB_ptr orb,
       Components::EventConsumerBase_ptr consumer);
 
     virtual void push (const RtecEventComm::EventSet& events);
diff --git a/TAO/CIAO/ciao/CIAO_Events.idl b/TAO/CIAO/ciao/CIAO_Events.idl
new file mode 100644
index 00000000000..b0764adcf18
--- /dev/null
+++ b/TAO/CIAO/ciao/CIAO_Events.idl
@@ -0,0 +1,58 @@
+// $Id$
+
+/**
+ * @file CIAO_Events.idl
+ *
+ * @author George Edwards
+ *
+ * @brief Interfaces for configuring CIAO's event mechanism.
+ */
+
+#include "CCM_Event.idl"
+#include "RtecEventChannelAdmin.idl"
+
+module CIAO_Events
+{
+  typedef long CONNECTION_ID;
+
+  enum EventServiceType
+  {
+    DIRECT,
+    EC,
+    RTEC,
+    NS,
+    RTNS
+  };
+
+  interface Consumer_Config
+  {
+    void set_consumer_id (in CONNECTION_ID connection_id);
+
+    void set_supplier_id (in CONNECTION_ID connection_id);
+
+    void set_consumer (in Components::EventConsumerBase consumer);
+
+    CONNECTION_ID get_consumer_id ();
+
+    CONNECTION_ID get_supplier_id ();
+
+    Components::EventConsumerBase get_consumer ();
+
+    EventServiceType get_service_type ();
+
+    RtecEventChannelAdmin::ConsumerQOS get_rt_event_qos ();
+  };
+
+
+  interface Supplier_Config
+  {
+    void set_supplier_id (in CONNECTION_ID connection_id);
+
+    CONNECTION_ID get_supplier_id ();
+
+    EventServiceType get_service_type ();
+
+    RtecEventChannelAdmin::SupplierQOS get_rt_event_qos ();
+  };
+
+};
diff --git a/TAO/CIAO/ciao/Container_Base.cpp b/TAO/CIAO/ciao/Container_Base.cpp
index 6d9a053d912..29c7d92ba11 100644
--- a/TAO/CIAO/ciao/Container_Base.cpp
+++ b/TAO/CIAO/ciao/Container_Base.cpp
@@ -10,8 +10,9 @@
 
 ////////////////////////////////////////////////////////////////
 
-CIAO::Container::Container (CORBA::ORB_ptr o)
-  : orb_ (CORBA::ORB::_duplicate (o))
+CIAO::Container::Container (CORBA::ORB_ptr o) :
+  orb_ (CORBA::ORB::_duplicate (o)),
+  events_manager_ (o)
 {
 }
 
@@ -31,6 +32,25 @@ CIAO::Container::_ciao_the_ORB ()
   return this->orb_.in ();
 }
 
+CIAO_Events::Consumer_Config_ptr CIAO::Container::_ciao_create_event_consumer_config (
+        const char * service_type
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  return this->events_manager_.create_consumer_config (service_type);
+}
+
+CIAO_Events::Supplier_Config_ptr CIAO::Container::_ciao_create_event_supplier_config (
+        const char * service_type
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException))
+{
+  return this->events_manager_.create_supplier_config (service_type);
+}
+
+/*
 ::Components::Cookie * CIAO::Container::_ciao_specify_event_service (
     const char * event_name,
     const char * publisher_name,
@@ -42,105 +62,132 @@ CIAO::Container::_ciao_the_ORB ()
 
   ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_specify_event_service\n"));
 
-  CIAO::EventServiceInfo service_info;
+  CIAO_EventServiceInfo service_info;
 
   if (ACE_OS::strcmp (service_name, "EC") == 0)
   {
-    service_info.service_type = EC;
+    service_info.type = EC;
+    if (this->event_service_ == 0)
+      {
+        ACE_NEW_RETURN (this->event_service_, CIAO_EventService, 0);
+      }
+    service_info.service = this->event_service_;
   }
   else if (ACE_OS::strcmp (service_name, "RTEC") == 0)
   {
-    service_info.service_type = RTEC;
+    service_info.type = RTEC;
+    if (this->rt_event_service_ == 0)
+      {
+        ACE_NEW_RETURN (this->rt_event_service_, CIAO_RTEventService (this->orb_.in ()), 0);
+      }
+    service_info.service = this->rt_event_service_;
   }
   else if (ACE_OS::strcmp (service_name, "NS") == 0)
   {
-    service_info.service_type = NS;
+    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.service_type = RTNS;
+    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.service_type = DIRECT;
+    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_;
   }
 
-  if (this->ciao_event_types_map_.find (event_name, service_info.event_type_id) == -1)
-    {
-      service_info.event_type_id =
-        ACE_ES_EVENT_ANY + 1 + this->ciao_event_types_map_.current_size ();
-      this->ciao_event_types_map_.bind (event_name, service_info.event_type_id);
-    }
-
-  if (this->ciao_publishers_map_.find (publisher_name, service_info.event_source_id) == -1)
-    {
-      service_info.event_source_id =
-        ACE_ES_EVENT_SOURCE_ANY + 1 + this->ciao_publishers_map_.current_size ();
-      this->ciao_publishers_map_.bind (publisher_name, service_info.event_source_id);
-    }
-
-  ACE_DEBUG ((LM_DEBUG, "service: %i\n", service_info.service_type));
-  ACE_DEBUG ((LM_DEBUG, "event: %i\n", service_info.event_type_id));
-  ACE_DEBUG ((LM_DEBUG, "source: %i\n", service_info.event_source_id));
+  service_info.service->specify_event_service (service_info,
+                                               event_name,
+                                               publisher_name
+                                               ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
 
-  ::Components::Cookie * return_cookie;
-  ACE_NEW_RETURN (return_cookie,
-                 ::CIAO::EventServiceInfo_Cookie (service_info),
-                 0);
+  ACE_Active_Map_Manager_Key key;
+  this->event_info_map_.bind (service_info, key);
+  ::CIAO::Map_Key_Cookie * return_cookie;
+  ACE_NEW_RETURN (return_cookie, ::CIAO::Map_Key_Cookie (key), 0);
   return return_cookie;
-
 }
+*/
 
-
-::Components::Cookie * CIAO::Container::_ciao_connect_event_consumer (
-    ::Components::EventConsumerBase_ptr c,
-    ::Components::Cookie *ck
+void CIAO::Container::_ciao_connect_event_consumer (
+    CIAO_Events::Consumer_Config_ptr consumer_config
     ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((
-    CORBA::SystemException ))
+    CORBA::SystemException))
 {
 
   ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_connect_event_consumer\n"));
 
-  CIAO::EventServiceInfo service_info;
+  CIAO_Events::EventServiceBase * event_service = 0;
 
-  if (CORBA::is_nil (c))
+  if (this->event_service_map_.find (consumer_config->get_supplier_id (), event_service) != 0)
     {
-      ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
+      ACE_THROW (
+      ::Components::InvalidConnection ());
     }
 
-  if (ck == 0 || ::CIAO::EventServiceInfo_Cookie::extract (ck, service_info) == -1)
+  CIAO_Events::EventServiceInfo service_info =
+    event_service->connect_event_consumer (consumer_config ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->event_info_map_.bind (consumer_config->get_consumer_id (),
+                              service_info);
+
+  /*
+
+  CIAO_EventServiceInfo service_info;
+  ACE_Active_Map_Manager_Key key;
+
+  if (ck == 0 || ::CIAO::Map_Key_Cookie::extract (ck, key) == -1)
     {
-      ACE_THROW (
-      ::Components::InvalidConnection ());
+      ACE_THROW_RETURN (
+      ::Components::InvalidConnection (),
+      0);
     }
 
-  ACE_DEBUG ((LM_DEBUG, "service: %i\n", service_info.service_type));
-  ACE_DEBUG ((LM_DEBUG, "event: %i\n", service_info.event_type_id));
-  ACE_DEBUG ((LM_DEBUG, "source: %i\n", service_info.event_source_id));
+  if (this->event_info_map_.find (key, service_info) != 0)
+    {
+      ACE_THROW_RETURN (
+      ::Components::InvalidConnection (),
+      0);
+    }
 
-  switch (service_info.service_type)
-  {
-  case EC:
-    break;
-  case RTEC:
-    return this->connect_rt_event_consumer (c, service_info);
-    break;
-  case NS:
-    break;
-  case RTNS:
-    break;
-  case DIRECT:
-    break;
-  }
+  if (CORBA::is_nil (consumer))
+    {
+      ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
+    }
 
-  return 0;
+  service_info.service->connect_event_consumer (consumer, service_info ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  ACE_Active_Map_Manager_Key new_key;
+  this->event_info_map_.bind (service_info, new_key);
+  ::CIAO::Map_Key_Cookie * return_cookie;
+  ACE_NEW_RETURN (return_cookie, ::CIAO::Map_Key_Cookie (new_key), 0);
+  return return_cookie;
+
+  */
 
 }
 
 
-::Components::Cookie * CIAO::Container::_ciao_connect_event_supplier (
-    ::Components::Cookie *ck
+void CIAO::Container::_ciao_connect_event_supplier (
+    CIAO_Events::Supplier_Config_ptr supplier_config
     ACE_ENV_ARG_DECL)
   ACE_THROW_SPEC ((
     CORBA::SystemException))
@@ -148,227 +195,108 @@ CIAO::Container::_ciao_the_ORB ()
 
   ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_connect_event_supplier\n"));
 
-  CIAO::EventServiceInfo service_info;
+  CIAO_Events::EventServiceBase * event_service =
+    this->events_manager_.create_supplier (supplier_config);
+
+  event_service->connect_event_supplier (supplier_config ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
+
+  this->event_service_map_.bind (supplier_config->get_supplier_id (),
+                                 event_service);
+
+  /*
+  CIAO_EventServiceInfo service_info;
+  ACE_Active_Map_Manager_Key key;
 
-  if (ck == 0 || ::CIAO::EventServiceInfo_Cookie::extract (ck, service_info) == -1)
+  if (ck == 0 || ::CIAO::Map_Key_Cookie::extract (ck, key) == -1)
     {
-      ACE_THROW (
-      ::Components::InvalidConnection ());
+      ACE_THROW_RETURN (
+      ::Components::InvalidConnection (),
+      0);
     }
 
-  switch (service_info.service_type)
-  {
-  case EC:
-    break;
-  case RTEC:
-    return this->connect_rt_event_supplier (service_info);
-    break;
-  case NS:
-    break;
-  case RTNS:
-    break;
-  case DIRECT:
-    break;
-  }
+  if (this->event_info_map_.find (key, service_info) != 0)
+    {
+      ACE_THROW_RETURN (
+      ::Components::InvalidConnection (),
+      0);
+    }
+
+  service_info.service->connect_event_supplier (service_info ACE_ENV_ARG_PARAMETER);
+  ACE_CHECK;
 
-  return 0;
+  ACE_Active_Map_Manager_Key new_key;
+  this->event_info_map_.bind (service_info, new_key);
+  ::CIAO::Map_Key_Cookie * return_cookie;
+  ACE_NEW_RETURN (return_cookie, ::CIAO::Map_Key_Cookie (new_key), 0);
+  return return_cookie;
+  */
 
 }
 
 void CIAO::Container::_ciao_disconnect_event_consumer
-      (::Components::Cookie *ck
+      (CIAO_Events::CONNECTION_ID connection_id
        ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((::CORBA::SystemException,
                        ::Components::InvalidName,
                        ::Components::InvalidConnection))
 {
-  ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_unsubscribe_event\n"));
+  ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_disconnect_event_consumer\n"));
 
-  CORBA::Object_var obj = CORBA::Object::_nil ();
-  PortableServer::ObjectId oid;
+  CIAO_Events::EventServiceInfo service_info;
 
-  if (ck == 0 || ::CIAO::ObjectId_Cookie::extract (ck, oid) == -1)
+  if (this->event_info_map_.unbind (connection_id, service_info) != 0)
     {
       ACE_THROW (
       ::Components::InvalidConnection ());
     }
 
-  obj = this->root_poa_->id_to_reference (oid ACE_ENV_ARG_PARAMETER);
+  service_info.service->disconnect_event_consumer (service_info ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
-  RtecEventComm::PushConsumer_var push_consumer =
-    RtecEventComm::PushConsumer::_narrow (obj.in ());
-  if (CORBA::is_nil (push_consumer.in ()))
-    {
-      ACE_THROW (
-        ::Components::InvalidConnection ());
-    }
-  push_consumer->disconnect_push_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
-	ACE_CHECK;
-  
 }
 
 void CIAO::Container::_ciao_disconnect_event_supplier
-      (::Components::Cookie *ck
+      (CIAO_Events::CONNECTION_ID connection_id
        ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((::CORBA::SystemException,
                        ::Components::InvalidName,
                        ::Components::InvalidConnection))
 {
+  ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_disconnect_event_supplier\n"));
 
-}
-
-void CIAO::Container::_ciao_push_event (::Components::EventBase *ev,
-                                       ::Components::Cookie *ck
-                                       ACE_ENV_ARG_DECL)
-                                      ACE_THROW_SPEC
-                                      ((CORBA::SystemException))
-{
-
-  ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_push_event\n"));
-
-  RtecEventComm::EventSet events (1);
-  events.length (1);
-  events[0].header.source = ACE_ES_EVENT_SOURCE_ANY;
-  events[0].header.type = ACE_ES_EVENT_ANY;
-  events[0].data.any_value <<= ev;
-  ev->_add_ref ();
+  CIAO_Events::EventServiceBase * event_service;
 
-  CORBA::Object_var obj = CORBA::Object::_nil ();
-  PortableServer::ObjectId oid;
-
-  if (ck == 0 || ::CIAO::ObjectId_Cookie::extract (ck, oid) == -1)
+  if (this->event_service_map_.unbind (connection_id, event_service) != 0)
     {
       ACE_THROW (
       ::Components::InvalidConnection ());
     }
 
-  obj = this->root_poa_->id_to_reference (oid ACE_ENV_ARG_PARAMETER);
+  event_service->disconnect_event_supplier (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;
-
-  RtecEventChannelAdmin::ProxyPushConsumer_var proxy_consumer =
-    RtecEventChannelAdmin::ProxyPushConsumer::_narrow (obj.in ());
-  if (CORBA::is_nil (proxy_consumer.in ()))
-    {
-      ACE_THROW (
-        ::Components::InvalidConnection ());
-    }
-  proxy_consumer->push (events ACE_ENV_ARG_PARAMETER);
-	ACE_CHECK;
 }
 
-void CIAO::Container::create_rt_event_channel (void)
+void CIAO::Container::_ciao_push_event (Components::EventBase *ev,
+                                        CIAO_Events::CONNECTION_ID connection_id
+                                        ACE_ENV_ARG_DECL)
+                                      ACE_THROW_SPEC ((
+                                        CORBA::SystemException))
 {
-  TAO_EC_Event_Channel_Attributes attributes (this->root_poa_.in (),
-                                              this->root_poa_.in ());
-  TAO_EC_Event_Channel * ec_servant;
-  ACE_NEW (ec_servant, TAO_EC_Event_Channel (attributes));
-  ec_servant->activate (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-  this->ciao_rt_event_channel_ = ec_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-}
-
-::Components::Cookie * CIAO::Container::connect_rt_event_consumer (
-    ::Components::EventConsumerBase_ptr c,
-    ::CIAO::EventServiceInfo service_info
-    ACE_ENV_ARG_DECL)
-  ACE_THROW_SPEC ((
-    CORBA::SystemException))
-{
-  if (CORBA::is_nil (this->ciao_rt_event_channel_.in ()))
-    {
-      this->create_rt_event_channel ();
-    }
-
-  ::Components::EventConsumerBase_var sub =
-    ::Components::EventConsumerBase::_duplicate (c);
-
-  RtecEventChannelAdmin::ConsumerAdmin_var consumer_admin =
-    this->ciao_rt_event_channel_->for_consumers (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-  RtecEventChannelAdmin::ProxyPushSupplier_var proxy_supplier =
-    consumer_admin->obtain_push_supplier (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-
-  // Create and register consumer servant
-  CIAO::RTEventServiceConsumer_impl * consumer_servant;
-  ACE_NEW_RETURN (consumer_servant,
-                  CIAO::RTEventServiceConsumer_impl (orb_.in (), sub.in ()),
-                  0);
-  RtecEventComm::PushConsumer_var push_consumer =
-    consumer_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-
-  // Set QoS properties and connect
-  ACE_ConsumerQOS_Factory qos;
-  qos.start_logical_and_group (2);
-  qos.insert_type (service_info.event_type_id,
-                   0);
-  qos.insert_source (service_info.event_source_id,
-                     0);
-  proxy_supplier->connect_push_consumer (push_consumer.in (),
-                                         qos.get_ConsumerQOS ()
-                                         ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
 
-  PortableServer::ObjectId_var oid = this->root_poa_->reference_to_id (push_consumer.in ());
+  ACE_DEBUG ((LM_DEBUG, "CIAO::Container::_ciao_push_event\n"));
 
-  ::Components::Cookie * return_cookie;
-  ACE_NEW_RETURN (return_cookie,
-                 ::CIAO::ObjectId_Cookie (oid.in ()),
-                 0);
-  return return_cookie;
-}
+  CIAO_Events::EventServiceBase * event_service;
 
-::Components::Cookie * CIAO::Container::connect_rt_event_supplier (
-    ::CIAO::EventServiceInfo service_info
-    ACE_ENV_ARG_DECL)
-  ACE_THROW_SPEC ((
-    CORBA::SystemException))
-{
-  if (CORBA::is_nil (this->ciao_rt_event_channel_.in ()))
+  if (this->event_service_map_.find (connection_id, event_service) != 0)
     {
-      this->create_rt_event_channel ();
+      ACE_THROW (
+      ::Components::InvalidConnection ());
     }
 
-  RtecEventChannelAdmin::SupplierAdmin_var supplier_admin =
-    this->ciao_rt_event_channel_->for_suppliers (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-
-  RtecEventChannelAdmin::ProxyPushConsumer_var proxy_consumer =
-    supplier_admin->obtain_push_consumer (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-
-  // Create and register supplier servant
-  CIAO::RTEventServiceSupplier_impl * supplier_servant;
-  ACE_NEW_RETURN (supplier_servant,
-                  CIAO::RTEventServiceSupplier_impl (orb_.in ()),
-                  0);
-  RtecEventComm::PushSupplier_var push_supplier =
-    supplier_servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER);
-  ACE_CHECK;
-
-  // Set QoS properties and connect
-  ACE_SupplierQOS_Factory qos;
-  qos.insert (service_info.event_source_id,
-              service_info.event_type_id,
-              0,
-              1);
-
-  proxy_consumer->connect_push_supplier (push_supplier.in (),
-                                         qos.get_SupplierQOS ()
-                                         ACE_ENV_ARG_PARAMETER);
+  event_service->push_event (ev ACE_ENV_ARG_PARAMETER);
   ACE_CHECK;
 
-  PortableServer::ObjectId_var oid = this->root_poa_->reference_to_id (proxy_consumer.in ());
-
-    ::Components::Cookie * return_cookie;
-  ACE_NEW_RETURN (return_cookie,
-                 ::CIAO::ObjectId_Cookie (oid.in ()),
-                 0);
-  return return_cookie;
-
 }
 
 ///////////////////////////////////////////////////////////////
@@ -414,7 +342,7 @@ CIAO::Session_Container::init (const char *name,
                         " (%P|%t) Unable to initialize the POA.\n"),
                        -1);
 
-   this->root_poa_ =
+   PortableServer::POA_var root_poa =
      PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
    ACE_CHECK_RETURN (-1);
 
@@ -428,7 +356,7 @@ CIAO::Session_Container::init (const char *name,
    if (more_policies != 0)
      policies = *more_policies;
 
-   this->poa_ = this->root_poa_->create_POA (name,
+   this->poa_ = root_poa->create_POA (name,
                                       PortableServer::POAManager::_nil (),
                                       policies
                                       ACE_ENV_ARG_PARAMETER);
@@ -601,70 +529,3 @@ CIAO::Session_Container::uninstall_component (CORBA::Object_ptr objref,
 
   oid = id._retn ();
 }
-
-CIAO::RTEventServiceSupplier_impl::RTEventServiceSupplier_impl (void)
-{
-}
-
-CIAO::RTEventServiceSupplier_impl::RTEventServiceSupplier_impl (CORBA::ORB_ptr orb) :
-  orb_ (CORBA::ORB::_duplicate (orb))
-{
-}
-  
-void CIAO::RTEventServiceSupplier_impl::disconnect_push_supplier (void)
-{
-  CORBA::Object_var poa_object =
-    orb_->resolve_initial_references ("RootPOA" ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
-  PortableServer::POA_var root_poa =
-    PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
-  if (CORBA::is_nil (root_poa.in ()))
-    ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
-  PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
-  root_poa->deactivate_object (oid);
-}
-
-CIAO::RTEventServiceConsumer_impl::RTEventServiceConsumer_impl (void)
-{
-}
-
-CIAO::RTEventServiceConsumer_impl::RTEventServiceConsumer_impl
-  (CORBA::ORB_ptr orb,
-   Components::EventConsumerBase_ptr consumer) :
-    orb_ (CORBA::ORB::_duplicate (orb)),
-    event_consumer_ (Components::EventConsumerBase::_duplicate (consumer))
-{
-}
-
-void CIAO::RTEventServiceConsumer_impl::push (const RtecEventComm::EventSet& events)
-{
-  ACE_DEBUG ((LM_DEBUG, "CIAO::RTEventServiceConsumer_impl::push\n"));
-  for (unsigned long i = 0; i < events.length (); ++i)
-    {
-      ::Components::EventBase * ev;
-      if (events[i].data.any_value >>= ev)
-        {
-          this->event_consumer_->push_event (ev
-                                           ACE_ENV_ARG_PARAMETER);
-          ACE_CHECK;
-        }
-    }
-}
-
-void CIAO::RTEventServiceConsumer_impl::disconnect_push_consumer (void)
-  ACE_THROW_SPEC ((CORBA::SystemException))
-{
-  ACE_DEBUG ((LM_DEBUG, "CIAO::RTEventServiceConsumer_impl::disconnect_push_consumer\n"));
-
-  CORBA::Object_var poa_object =
-    orb_->resolve_initial_references ("RootPOA" ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
-  PortableServer::POA_var root_poa =
-    PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER);
-  ACE_CHECK;
-  if (CORBA::is_nil (root_poa.in ()))
-    ACE_ERROR ((LM_ERROR, "Nil RootPOA\n"));
-  PortableServer::ObjectId_var oid = root_poa->servant_to_id (this);
-  root_poa->deactivate_object (oid);
-}
diff --git a/TAO/CIAO/ciao/Container_Base.h b/TAO/CIAO/ciao/Container_Base.h
index 3e3297e26bd..ca86b2983b5 100644
--- a/TAO/CIAO/ciao/Container_Base.h
+++ b/TAO/CIAO/ciao/Container_Base.h
@@ -22,7 +22,7 @@
 #include "tao/PortableServer/Servant_Base.h"
 #include "CCM_ContainerC.h"
 #include "CCM_DeploymentC.h"
-#include "ace/Hash_Map_Manager.h"
+#include "ace/Active_Map_Manager.h"
 #include "CIAO_Events.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
@@ -84,75 +84,66 @@ namespace CIAO
 
     // Events methods
 
-    virtual ::Components::Cookie * _ciao_specify_event_service (
-        const char * event_name,
-        const char * publisher_name,
-        const char * service_name
+    CIAO_Events::Consumer_Config_ptr _ciao_create_event_consumer_config (
+        const char * service_type
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
-    virtual ::Components::Cookie * _ciao_connect_event_consumer (
-        ::Components::EventConsumerBase_ptr c,
-        ::Components::Cookie * ck
+    CIAO_Events::Supplier_Config_ptr _ciao_create_event_supplier_config (
+        const char * service_type
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
-    virtual ::Components::Cookie * _ciao_connect_event_supplier (
-        ::Components::Cookie * ck
+    virtual void _ciao_connect_event_consumer (
+        CIAO_Events::Consumer_Config_ptr consumer_config
+        ACE_ENV_ARG_DECL)
+      ACE_THROW_SPEC ((
+        CORBA::SystemException));
+
+    virtual void _ciao_connect_event_supplier (
+        CIAO_Events::Supplier_Config_ptr supplier_config
         ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((
         CORBA::SystemException));
 
     virtual void _ciao_disconnect_event_consumer (
-      ::Components::Cookie *ck
-       ACE_ENV_ARG_DECL)
+        CIAO_Events::CONNECTION_ID connection_id
+        ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((::CORBA::SystemException,
                        ::Components::InvalidName,
                        ::Components::InvalidConnection));
 
     virtual void _ciao_disconnect_event_supplier (
-      ::Components::Cookie *ck
-       ACE_ENV_ARG_DECL)
+        CIAO_Events::CONNECTION_ID connection_id
+        ACE_ENV_ARG_DECL)
       ACE_THROW_SPEC ((::CORBA::SystemException,
                        ::Components::InvalidName,
                        ::Components::InvalidConnection));
 
     virtual void _ciao_push_event (::Components::EventBase *ev,
-                                   ::Components::Cookie *ck
+                                   CIAO_Events::CONNECTION_ID connection_id
                                    ACE_ENV_ARG_DECL)
                                  ACE_THROW_SPEC ((CORBA::SystemException));
 
   protected:
 
-    ::Components::Cookie * connect_rt_event_consumer (
-        ::Components::EventConsumerBase_ptr c,
-        ::CIAO::EventServiceInfo service_info
-        ACE_ENV_ARG_DECL)
-      ACE_THROW_SPEC ((
-        CORBA::SystemException));
-
-    ::Components::Cookie * connect_rt_event_supplier (
-        ::CIAO::EventServiceInfo service_info
-        ACE_ENV_ARG_DECL)
-      ACE_THROW_SPEC ((
-        CORBA::SystemException));
-
-    void CIAO::Container::create_rt_event_channel (void);
-
     // Reference to the ORB
     CORBA::ORB_var orb_;
 
     // Reference to the POA
     PortableServer::POA_var poa_;
 
-    // Reference to the Root POA
-    PortableServer::POA_var root_poa_;
+    ACE_Hash_Map_Manager<CIAO_Events::CONNECTION_ID,
+                         CIAO_Events::EventServiceBase *,
+                         ACE_Null_Mutex> event_service_map_;
+
+    ACE_Hash_Map_Manager<CIAO_Events::CONNECTION_ID,
+                         CIAO_Events::EventServiceInfo,
+                         ACE_Null_Mutex> event_info_map_;
 
-    // Map of CIAO event services
-    ACE_Hash_Map_Manager<long, CIAO_EventServiceBase *>
-      event_services_map;
+    CIAO_Events::Events_Manager events_manager_;
   };
 
   class CIAO_SERVER_Export Session_Container : public Container
diff --git a/TAO/CIAO/ciao/Cookies.cpp b/TAO/CIAO/ciao/Cookies.cpp
index f8c02805f5e..d0787c3b221 100644
--- a/TAO/CIAO/ciao/Cookies.cpp
+++ b/TAO/CIAO/ciao/Cookies.cpp
@@ -123,6 +123,7 @@ CIAO::ObjectId_Cookie::get_cookie (ACE_ENV_SINGLE_ARG_DECL)
   return &this->cookieValue ();
 }
 
+/*
 CIAO::EventServiceInfo_Cookie::EventServiceInfo_Cookie ()
 {
 
@@ -133,14 +134,14 @@ CIAO::EventServiceInfo_Cookie::~EventServiceInfo_Cookie ()
 
 }
 
-CIAO::EventServiceInfo_Cookie::EventServiceInfo_Cookie (const CIAO::EventServiceInfo &info)
+CIAO::EventServiceInfo_Cookie::EventServiceInfo_Cookie (const CIAO::CIAO_EventServiceInfo &info)
 {
   this->cookieValue ().length (sizeof (info));
   ACE_OS::memcpy (this->cookieValue ().get_buffer (0), (void *)&info, this->cookieValue ().length ());
 }
 
 int
-CIAO::EventServiceInfo_Cookie::insert (const CIAO::EventServiceInfo &info)
+CIAO::EventServiceInfo_Cookie::insert (const CIAO::CIAO_EventServiceInfo &info)
 {
   this->cookieValue ().length (sizeof (info));
   ACE_OS::memcpy (this->cookieValue ().get_buffer (0), (void *)&info, this->cookieValue ().length ());
@@ -149,7 +150,7 @@ CIAO::EventServiceInfo_Cookie::insert (const CIAO::EventServiceInfo &info)
 
 int
 CIAO::EventServiceInfo_Cookie::extract (::Components::Cookie *ck,
-                                        CIAO::EventServiceInfo &info)
+                                        CIAO::CIAO_EventServiceInfo &info)
 {
   CIAO::Cookie *c = CIAO::Cookie::_downcast (ck);
 
@@ -161,7 +162,7 @@ CIAO::EventServiceInfo_Cookie::extract (::Components::Cookie *ck,
   if (x == 0)
     return -1;
 
-  info = *((CIAO::EventServiceInfo *) x->get_buffer ());
+  info = *((CIAO::CIAO_EventServiceInfo *) x->get_buffer ());
   return 0;
 }
 
@@ -181,3 +182,4 @@ CIAO::EventServiceInfo_Cookie::get_cookie (ACE_ENV_SINGLE_ARG_DECL)
 {
   return &this->cookieValue ();
 }
+*/
diff --git a/TAO/CIAO/ciao/Cookies.h b/TAO/CIAO/ciao/Cookies.h
index db15c37d679..ace9ca64c7b 100644
--- a/TAO/CIAO/ciao/Cookies.h
+++ b/TAO/CIAO/ciao/Cookies.h
@@ -114,6 +114,7 @@ namespace CIAO
    *
    * @brief A CIAO internal Cookie valuetype implementation.
    */
+  /*
   class CIAO_CONTAINER_Export EventServiceInfo_Cookie
     : public virtual OBV_CIAO::Cookie
   {
@@ -124,16 +125,16 @@ namespace CIAO
     EventServiceInfo_Cookie ();
 
     /// Initialize a @c Cookie with an object reference.
-    EventServiceInfo_Cookie (const CIAO::EventServiceInfo &info);
+    EventServiceInfo_Cookie (const CIAO::CIAO_EventServiceInfo &info);
 
     virtual ::CORBA::OctetSeq * get_cookie (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
     ~EventServiceInfo_Cookie ();
 
-    int insert (const CIAO::EventServiceInfo &info);
+    int insert (const CIAO::CIAO_EventServiceInfo &info);
 
     static int extract (::Components::Cookie *ck,
-                        CIAO::EventServiceInfo &info);
+                        CIAO::CIAO_EventServiceInfo &info);
   };
 
   class EventServiceInfo_Cookie_init : public virtual ::Components::Cookie_init
@@ -146,6 +147,7 @@ namespace CIAO
 
     virtual CORBA::ValueBase * create_for_unmarshal (void);
   };
+  */
 }
 
 #if defined (__ACE_INLINE__)
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 d6ff0983e34..0713f949d41 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMClosedED/BMClosedED_svnt.cpp
@@ -252,7 +252,7 @@ namespace CIAO_GLUE_BasicSP
   ACE_THROW_SPEC ((CORBA::SystemException))
   {
     this->container_->_ciao_push_event (ev,
-                                        this->push_out_avail_cookie_
+                                        0301
                                         ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
@@ -288,31 +288,28 @@ namespace CIAO_GLUE_BasicSP
   ::CORBA::SystemException,
   ::Components::ExceededConnectionLimit))
   {
-    if (this->out_avail_service_cookie_ == 0)
-      {
-        this->out_avail_service_cookie_ =
-          this->container_->_ciao_specify_event_service (
-            "DataAvailable",
-            "out_avail",
-            "RTEC"
-            ACE_ENV_ARG_PARAMETER);
-        ACE_CHECK;
-      }
+    CIAO_Events::Supplier_Config_var supplier_config =
+      this->container_->_ciao_create_event_supplier_config ("RTEC" ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    supplier_config->set_supplier_id (0301 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    if (this->push_out_avail_cookie_ == 0)
-      {
-        this->push_out_avail_cookie_ =
-          this->container_->_ciao_connect_event_supplier (
-            this->out_avail_service_cookie_
-            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);
+    ACE_CHECK;
+    consumer_config->set_supplier_id (0301 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer_id (0302 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer (c ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    return this->container_->_ciao_connect_event_consumer (
-      c,
-      this->out_avail_service_cookie_
-      ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_connect_event_supplier (supplier_config.in () ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
+    this->container_->_ciao_connect_event_consumer (consumer_config.in () ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+
+    return 0;
 
     /*
 
@@ -343,7 +340,7 @@ namespace CIAO_GLUE_BasicSP
   ::Components::InvalidConnection))
   {
 
-    this->container_->_ciao_disconnect_event_consumer (ck ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_disconnect_event_consumer (0302 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     return ::BasicSP::DataAvailableConsumer::_nil ();
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 14dc200a443..03650f68cb3 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/BMDevice/BMDevice_svnt.cpp
@@ -203,7 +203,7 @@ namespace CIAO_GLUE_BasicSP
   ACE_THROW_SPEC ((CORBA::SystemException))
   {
     this->container_->_ciao_push_event (ev,
-                                        this->push_data_available_cookie_
+                                        0201
                                         ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
@@ -240,31 +240,28 @@ namespace CIAO_GLUE_BasicSP
   ::Components::ExceededConnectionLimit))
   {
 
-    if (this->data_available_service_cookie_ == 0)
-      {
-        this->data_available_service_cookie_ =
-          this->container_->_ciao_specify_event_service (
-            "DataAvailable",
-            "data_available",
-            "RTEC"
-            ACE_ENV_ARG_PARAMETER);
-        ACE_CHECK;
-      }
+    CIAO_Events::Supplier_Config_var supplier_config =
+      this->container_->_ciao_create_event_supplier_config ("DIRECT" ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    supplier_config->set_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    if (this->push_data_available_cookie_ == 0)
-      {
-        this->push_data_available_cookie_ =
-          this->container_->_ciao_connect_event_supplier (
-          this->data_available_service_cookie_
-          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);
+    ACE_CHECK;
+    consumer_config->set_supplier_id (0201 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer_id (0202 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer (c ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    return this->container_->_ciao_connect_event_consumer (
-      c,
-      this->data_available_service_cookie_
-      ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_connect_event_supplier (supplier_config.in () ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
+    this->container_->_ciao_connect_event_consumer (consumer_config.in () ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+
+    return 0;
 
     /*
     if (CORBA::is_nil (c))
@@ -293,7 +290,7 @@ namespace CIAO_GLUE_BasicSP
   ::CORBA::SystemException,
   ::Components::InvalidConnection))
   {
-    this->container_->_ciao_disconnect_event_consumer (ck ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_disconnect_event_consumer (0202 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     return ::BasicSP::DataAvailableConsumer::_nil ();
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 4e0d67f0f31..84a904d9ab4 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.cpp
@@ -30,8 +30,7 @@ namespace CIAO_GLUE_BasicSP
   : home_ (::Components::CCMHome::_duplicate (home)),
   container_ (c),
   servant_ (sv),
-  push_timeout_cookie_ (0),
-  timeout_service_cookie_ (0)
+  push_timeout_cookie_ (0)
   {
   }
 
@@ -179,7 +178,7 @@ namespace CIAO_GLUE_BasicSP
   ACE_THROW_SPEC ((CORBA::SystemException))
   {
     this->container_->_ciao_push_event (ev,
-                                        this->push_timeout_cookie_
+                                        0101
                                         ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
     
@@ -229,33 +228,29 @@ namespace CIAO_GLUE_BasicSP
   ::CORBA::SystemException,
   ::Components::ExceededConnectionLimit))
   {
+    CIAO_Events::Supplier_Config_var supplier_config =
+      this->container_->_ciao_create_event_supplier_config ("RTEC" ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    supplier_config->set_supplier_id (0101 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    if (this->timeout_service_cookie_ == 0)
-      {
-        this->timeout_service_cookie_ =
-          this->container_->_ciao_specify_event_service (
-            "TimeOut",
-            "timeout",
-            "RTEC"
-            ACE_ENV_ARG_PARAMETER);
-        ACE_CHECK;
-      }
-
-    if (this->push_timeout_cookie_ == 0)
-      {
-        this->push_timeout_cookie_ =
-          this->container_->_ciao_connect_event_supplier (
-            this->timeout_service_cookie_
-            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);
+    ACE_CHECK;
+    consumer_config->set_supplier_id (0101 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer_id (0102 ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    consumer_config->set_consumer (c ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
 
-    return this->container_->_ciao_connect_event_consumer (
-      c,
-      this->timeout_service_cookie_
-      ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_connect_event_supplier (supplier_config.in () ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+    this->container_->_ciao_connect_event_consumer (consumer_config.in () ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
+    return 0;
+
     /*
     // START new event code
     CORBA::ORB_var orb = this->container_->_ciao_the_ORB ();
@@ -371,7 +366,7 @@ namespace CIAO_GLUE_BasicSP
   ::Components::InvalidConnection))
   {
 
-    this->container_->_ciao_disconnect_event_consumer (ck ACE_ENV_ARG_PARAMETER);
+    this->container_->_ciao_disconnect_event_consumer (0102 ACE_ENV_ARG_PARAMETER);
     ACE_CHECK;
 
     return ::BasicSP::TimeOutConsumer::_nil ();
diff --git a/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.h b/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.h
index 6a827e26e6a..308736c61eb 100644
--- a/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.h
+++ b/TAO/CIAO/examples/handcrafted/BasicSP_EC/EC/EC_svnt.h
@@ -181,7 +181,6 @@ namespace CIAO_GLUE_BasicSP
 
     ::Components::Cookie * push_timeout_cookie_;
 
-    ::Components::Cookie * timeout_service_cookie_;
   };
 
   class EC_SVNT_Export EC_Servant