Mon Jun 28 09:18:43 UTC 2010 Johnny Willemsen <jwillemsen@remedy.nl>

        * DAnCE/LocalityManager/Interceptors/Error_Interceptors.mpc:
          Fixed fuzz

        * connectors/dds4ccm/impl/ContentFilteredTopic_T.h:
        * connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp:
        * connectors/dds4ccm/impl/DDSDataReaderListener_T.h:
        * connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp:
        * connectors/dds4ccm/impl/DDSDataWriterListener_T.h:
        * connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp:
        * connectors/dds4ccm/impl/DDSPublisherListener_T.h:
        * connectors/dds4ccm/impl/DDSPublisherListener_T.cpp:
        * connectors/dds4ccm/impl/DDSSubscriberListener_T.h:
        * connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp:
        * connectors/dds4ccm/impl/DDSTopicListener_T.h:
        * connectors/dds4ccm/impl/DDSTopicListener_T.cpp:
        * connectors/dds4ccm/impl/DDS_Base_Connector_T.h:
        * connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp:
        * connectors/dds4ccm/impl/DDS_Event_Connector_T.h:
        * connectors/dds4ccm/impl/DDS_Event_Connector_T.cpp:
        * connectors/dds4ccm/impl/DDS_Get_T.h:
        * connectors/dds4ccm/impl/DDS_Get_T.cpp:
        * connectors/dds4ccm/impl/DDS_Listen_T.h:
        * connectors/dds4ccm/impl/DDS_Listen_T.cpp:
        * connectors/dds4ccm/impl/DDS_Read_T.h:
        * connectors/dds4ccm/impl/DDS_Read_T.cpp:
        * connectors/dds4ccm/impl/DDS_StateListen_T.h:
        * connectors/dds4ccm/impl/DDS_StateListen_T.cpp:
        * connectors/dds4ccm/impl/DDS_State_Connector_T.h:
        * connectors/dds4ccm/impl/DDS_State_Connector_T.cpp:
        * connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h:
        * connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp:
        * connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h:
        * connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp:
        * connectors/dds4ccm/impl/DDS_Update_T.h:
        * connectors/dds4ccm/impl/DDS_Update_T.cpp:
        * connectors/dds4ccm/impl/DDS_Write_T.h:
        * connectors/dds4ccm/impl/DDS_Write_T.cpp:
        * connectors/dds4ccm/impl/DataReaderHandler_T.h:
        * connectors/dds4ccm/impl/DataReaderHandler_T.cpp:
        * connectors/dds4ccm/impl/DataReaderListener_T.h:
        * connectors/dds4ccm/impl/DataReaderListener_T.cpp:
        * connectors/dds4ccm/impl/DataReaderStateListener_T.h:
        * connectors/dds4ccm/impl/DataReaderStateListener_T.cpp:
        * connectors/dds4ccm/impl/DataReader_T.h:
        * connectors/dds4ccm/impl/DataReader_T.cpp:
        * connectors/dds4ccm/impl/DataWriterListener_T.h:
        * connectors/dds4ccm/impl/DataWriterListener_T.cpp:
        * connectors/dds4ccm/impl/DataWriter_T.h:
        * connectors/dds4ccm/impl/DataWriter_T.cpp:
        * connectors/dds4ccm/impl/DomainParticipantFactory_T.h:
        * connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp:
        * connectors/dds4ccm/impl/DomainParticipantListener_T.h:
        * connectors/dds4ccm/impl/DomainParticipantListener_T.cpp:
        * connectors/dds4ccm/impl/DomainParticipant_T.h:
        * connectors/dds4ccm/impl/DomainParticipant_T.cpp:
        * connectors/dds4ccm/impl/Getter_T.h:
        * connectors/dds4ccm/impl/Getter_T.cpp:
        * connectors/dds4ccm/impl/InstanceHandleManager_T.h:
        * connectors/dds4ccm/impl/InstanceHandleManager_T.cpp:
        * connectors/dds4ccm/impl/PortStatusListener_T.h:
        * connectors/dds4ccm/impl/PortStatusListener_T.cpp:
        * connectors/dds4ccm/impl/PublisherListener_T.h:
        * connectors/dds4ccm/impl/PublisherListener_T.cpp:
        * connectors/dds4ccm/impl/Publisher_T.h:
        * connectors/dds4ccm/impl/Publisher_T.cpp:
        * connectors/dds4ccm/impl/QueryCondition_T.h:
        * connectors/dds4ccm/impl/QueryCondition_T.cpp:
        * connectors/dds4ccm/impl/ReadCondition_T.h:
        * connectors/dds4ccm/impl/ReadCondition_T.cpp:
        * connectors/dds4ccm/impl/Reader_T.h:
        * connectors/dds4ccm/impl/Reader_T.cpp:
        * connectors/dds4ccm/impl/SubscriberListener_T.h:
        * connectors/dds4ccm/impl/SubscriberListener_T.cpp:
        * connectors/dds4ccm/impl/Subscriber_T.h:
        * connectors/dds4ccm/impl/Subscriber_T.cpp:
        * connectors/dds4ccm/impl/TopicDescription_T.h:
        * connectors/dds4ccm/impl/TopicDescription_T.cpp:
        * connectors/dds4ccm/impl/TopicListener_T.h:
        * connectors/dds4ccm/impl/TopicListener_T.cpp:
        * connectors/dds4ccm/impl/Topic_T.h:
        * connectors/dds4ccm/impl/Topic_T.cpp:
        * connectors/dds4ccm/impl/Updater_T.h:
        * connectors/dds4ccm/impl/Updater_T.cpp:
        * connectors/dds4ccm/impl/Writer_T.h:
        * connectors/dds4ccm/impl/Writer_T.cpp:
        * connectors/dds4ccm/impl/dds4ccm_conf.h:
        * connectors/dds4ccm/tests/PSAT/DDS_PSAT_Connector_T.h:
          Added a vendor traits to the template. The idea is that when other
          DDS vendors need to be integrated, the default implementation will
          assume DDS and DDS4CCM have the same IDL to C++ mapping, if there
          are differences for a certain vendor, use partial template
          specialization to change methods for a certain vendor. This keeps
          the core clean and adding more vendors doesn't make the
          core unreadable. Currently the core is just for RTI DDS, integrating
          a second vendor will mean part of the code has to be moved to a RTI
          partial template specialization

85 files changed, 1567 insertions, 2105 deletions

diff --git a/CIAO/DAnCE/LocalityManager/Interceptors/Error_Interceptors.mpc b/CIAO/DAnCE/LocalityManager/Interceptors/Error_Interceptors.mpc
index c769e3a9aa0..94cde7e2123 100644
--- a/CIAO/DAnCE/LocalityManager/Interceptors/Error_Interceptors.mpc
+++ b/CIAO/DAnCE/LocalityManager/Interceptors/Error_Interceptors.mpc
@@ -1,4 +1,5 @@
-// $id$
+// $Id$
+
 project (DAnCE_Error_Interceptors) : dance_skel, dance_lib, dance_output, dance_logger {
    dynamicflags = DANCE_ERROR_INTERCEPTORS_BUILD_DLL
 
diff --git a/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp
index 0bf31adedee..5f77938a28d 100644
--- a/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp
@@ -12,139 +12,107 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_ContentFilteredTopic_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_ContentFilteredTopic_T (
       DDSContentFilteredTopic * dw) : impl_ (dw)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_ContentFilteredTopic_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_ContentFilteredTopic_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_filter_expression (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_filter_expression (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_filter_expression");
+      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_filter_expression");
       return CORBA::string_dup (this->impl ()->get_filter_expression ());
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_expression_parameters (
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_expression_parameters (
       ::DDS::StringSeq & expression_parameters)
     {
-      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_expression_parameters");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_expression_parameters");
       DDS_StringSeq parameters;
       ::DDS::ReturnCode_t retval =
         this->impl ()->get_expression_parameters (parameters);
       expression_parameters <<= parameters;
-#else
-      ::DDS::ReturnCode_t const retval =
-        this->impl ()->get_expression_parameters (expression_parameters);
-#endif
       return retval;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::set_expression_parameters (
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_expression_parameters (
       const ::DDS::StringSeq & expression_parameters)
     {
-      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::set_expression_parameters");
+      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_expression_parameters");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_StringSeq parameters;
       parameters <<= expression_parameters;
       return this->impl ()->set_expression_parameters (parameters);
-#else
-      return this->impl ()->set_expression_parameters (expression_parameters);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_related_topic (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_related_topic (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_related_topic");
+      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_related_topic");
 
       ::DDS::Topic_var retval = ::DDS::Topic::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSTopic *topic = this->impl ()->get_related_topic ();
       ACE_NEW_THROW_EX (retval,
                         Topic_type (topic),
                         CORBA::NO_MEMORY ());
       return retval._retn ();
-#else
-      ::DDS::Topic_var topic = this->impl ()->get_related_topic ();
-      ACE_NEW_THROW_EX (retval,
-                        Topic_type (topic.in ()),
-                        CORBA::NO_MEMORY ());
-      return retval._retn ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_type_name (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_type_name ());
-#else
-      return this->impl ()->get_type_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_name (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_name ());
-#else
-      return this->impl ()->get_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_participant (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDomainParticipant * p = this->impl ()->get_participant ();
       ACE_NEW_THROW_EX (retval,
                         DomainParticipant_type (p),
                         CORBA::NO_MEMORY ());
-#else
-      ::DDS::DomainParticipant_var p = this->impl ()->get_participant ();
-      ACE_NEW_THROW_EX (retval,
-                        DomainParticipant_type (p.in ()),
-                        CORBA::NO_MEMORY ());
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSContentFilteredTopic *
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSContentFilteredTopic * dw)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSContentFilteredTopic * dw)
     {
       this->impl_ = dw;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSContentFilteredTopic *
-    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h
index 347f4d6b713..3560303faea 100644
--- a/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h
+++ b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h
@@ -22,13 +22,13 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ContentFilteredTopic_T :
       public virtual ::DDS::CCM_ContentFilteredTopic,
       public virtual ::CORBA::LocalObject
     {
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
-    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
+    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
     public:
       /// Constructor
       CCM_DDS_ContentFilteredTopic_T (DDSContentFilteredTopic * dw);
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
index acc52722dd1..24225230edd 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
@@ -18,8 +18,8 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DataReaderListener_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DataReaderListener_T (
           ::DDS::DataReaderListener_ptr p,
           DataReader_type *typed_dr)
       : impl_ (::DDS::DataReaderListener::_duplicate (p)),
@@ -27,18 +27,18 @@ namespace CIAO
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DataReaderListener_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DataReaderListener_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed (
       ::DDSDataReader* ,
       const ::DDS_RequestedDeadlineMissedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed");
       ::DDS::RequestedDeadlineMissedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_requested_deadline_missed (
@@ -46,13 +46,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos (
       ::DDSDataReader* ,
       const ::DDS_RequestedIncompatibleQosStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos");
       ::DDS::RequestedIncompatibleQosStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_requested_incompatible_qos (
@@ -60,13 +60,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected (
       ::DDSDataReader* ,
       const ::DDS_SampleRejectedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected");
       ::DDS::SampleRejectedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_sample_rejected (
@@ -74,13 +74,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed (
       ::DDSDataReader* ,
       const ::DDS_LivelinessChangedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed");
       ::DDS::LivelinessChangedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_liveliness_changed (
@@ -88,22 +88,22 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available(::DDSDataReader *)
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available(::DDSDataReader *)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available");
       this->impl_->on_data_available (
         this->typed_dr_);
     }
         
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched (
       ::DDSDataReader* ,
       const ::DDS_SubscriptionMatchedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched");
       ::DDS::SubscriptionMatchedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_subscription_matched (
@@ -111,13 +111,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost (
       ::DDSDataReader* ,
       const ::DDS_SampleLostStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost");
+      DDS4CCM_TRACE ("CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost");
       ::DDS::SampleLostStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_sample_lost (
@@ -125,9 +125,9 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReaderListener_ptr
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>::get_datareaderlistener (void)
+    CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareaderlistener (void)
     {
       return ::DDS::DataReaderListener::_duplicate (this->impl_.in ());
     }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h
index 41d7144167d..541dabd795b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h
@@ -35,11 +35,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataReaderListener_T :
       public virtual ::DDSDataReaderListener
     {
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
     public:
       /// Constructor
       CCM_DDS_DataReaderListener_T (::DDS::DataReaderListener_ptr p,
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp
index 65f105174fc..b8954726efe 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp
@@ -14,8 +14,8 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DataWriterListener_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DataWriterListener_T (
       ::DDS::DataWriterListener_ptr s,
       DataWriter_type * typed_dw)
       : impl_ (::DDS::DataWriterListener::_duplicate (s)),
@@ -23,94 +23,68 @@ namespace CIAO
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DataWriterListener_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DataWriterListener_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed (
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed (
       ::DDSDataWriter *,
       const ::DDS_OfferedDeadlineMissedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed");
       ::DDS::OfferedDeadlineMissedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_offered_deadline_missed (
         this->typed_dw_,
         ddsstatus);
-#else
-      this->impl_->on_offered_deadline_missed (
-        this->typed_dw_,
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos (
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos (
       ::DDSDataWriter *,
       const ::DDS_OfferedIncompatibleQosStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos");
       ::DDS::OfferedIncompatibleQosStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_offered_incompatible_qos (
         this->typed_dw_,
         ddsstatus);
-#else
-      this->impl_->on_offered_incompatible_qos (
-        this->typed_dw_,
-        ddsstatus);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost (
       ::DDSDataWriter *,
       const ::DDS_LivelinessLostStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost");
       ::DDS::LivelinessLostStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_liveliness_lost (
         this->typed_dw_,
         ddsstatus);
-#else
-      this->impl_->on_liveliness_lost (
-        this->typed_dw_,
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched (
       ::DDSDataWriter *,
       const ::DDS_PublicationMatchedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched");
       ::DDS::PublicationMatchedStatus ddsstatus;
       ddsstatus <<= status;
-      this->impl_->on_publication_matched (
-        this->typed_dw_,
-        ddsstatus);
-#else
-      this->impl_->on_publication_matched ();
-        this->typed_dw_,
-        ddsstatus);
-#endif
+      this->impl_->on_publication_matched (this->typed_dw_, ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriterListener_ptr
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE>::get_datawriterlistener (void)
+    CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datawriterlistener (void)
     {
       return ::DDS::DataWriterListener::_duplicate (this->impl_.in ());
     }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h
index f28293a3c2a..32009f18e2f 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h
@@ -34,11 +34,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T :
       public virtual ::DDSDataWriterListener
     {
-    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> DataWriter_type;
+    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriter_type;
     public:
       /// Constructor
       CCM_DDS_DataWriterListener_T (::DDS::DataWriterListener_ptr p,
diff --git a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp
index 17ae8384bc8..044a418ede3 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp
@@ -19,159 +19,123 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_PublisherListener_T ( ::DDS::PublisherListener_ptr p)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_PublisherListener_T ( ::DDS::PublisherListener_ptr p)
       : impl_ (::DDS::PublisherListener::_duplicate (p))
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_PublisherListener_T");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_PublisherListener_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_PublisherListener_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_PublisherListener_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_PublisherListener_T");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_PublisherListener_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::CCM_DataWriter_ptr
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::get_datawriter_proxy (::DDSDataWriter * the_writer)
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datawriter_proxy (::DDSDataWriter * the_writer)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::get_datawriter_proxy");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datawriter_proxy");
       ::DDS::CCM_DataWriter_var dds_writer = ::DDS::CCM_DataWriter::_nil ();
       ACE_NEW_NORETURN (dds_writer,
                         DataWriter_type (the_writer));
       return dds_writer._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed (
       ::DDSDataWriter* the_writer,
       const ::DDS_OfferedDeadlineMissedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::OfferedDeadlineMissedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_offered_deadline_missed (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_offered_deadline_missed (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos (
       ::DDSDataWriter* the_writer,
       const ::DDS_OfferedIncompatibleQosStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::OfferedIncompatibleQosStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_offered_incompatible_qos (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_offered_incompatible_qos (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost (
       ::DDSDataWriter* the_writer,
       const ::DDS_LivelinessLostStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::LivelinessLostStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_liveliness_lost (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_liveliness_lost (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched (
       ::DDSDataWriter* the_writer,
       const ::DDS_PublicationMatchedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::PublicationMatchedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_publication_matched (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_publication_matched (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activity_changed (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed (
       ::DDSDataWriter *the_writer,
       const ::DDS_ReliableReaderActivityChangedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activity_changed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::ReliableReaderActivityChangedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_reliable_reader_activity_changed (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_reliable_reader_activity_changed (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache_changed (
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed (
       ::DDSDataWriter* the_writer,
       const ::DDS_ReliableWriterCacheChangedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache_changed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::ReliableWriterCacheChangedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_reliable_writer_cache_changed (
         this->get_datawriter_proxy (the_writer),
         ddsstatus);
-#else
-      this->impl_->on_reliable_writer_cache_changed (
-        this->get_datawriter_proxy (the_writer),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::PublisherListener_ptr
-    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE>::get_publisher_listener (void)
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_publisher_listener (void)
     {
       return ::DDS::PublisherListener::_duplicate (this->impl_.in ());
     }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h
index 5f1a1247359..1c52b6ede67 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h
@@ -37,14 +37,14 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriter_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T :
       public virtual ::DDSPublisherListener
     {
-    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> DataWriter_type;
+    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriter_type;
     public:
       /// Constructor
       CCM_DDS_PublisherListener_T (::DDS::PublisherListener_ptr p);
diff --git a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
index 13db52c3659..e59cc246641 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
@@ -16,25 +16,25 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_SubscriberListener_T (::DDS::SubscriberListener_ptr p)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_SubscriberListener_T (::DDS::SubscriberListener_ptr p)
       : impl_ ( ::DDS::SubscriberListener::_duplicate (p))
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_SubscriberListener_T");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_SubscriberListener_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_SubscriberListener_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_SubscriberListener_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_SubscriberListener_T");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_SubscriberListener_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_on_readers (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_on_readers (
         ::DDSSubscriber* the_subscriber)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_on_readers");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_on_readers");
 
       ::DDS::Subscriber_var sub = ::DDS::Subscriber::_nil ();
       ACE_NEW (sub,
@@ -43,158 +43,121 @@ namespace CIAO
       the_subscriber->notify_datareaders ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::CCM_DataReader_ptr
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::get_datareader_proxy (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader_proxy (
       ::DDSDataReader * the_reader)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::get_datareader_proxy");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader_proxy");
       ::DDS::CCM_DataReader_var dds_reader = ::DDS::CCM_DataReader::_nil ();
       ACE_NEW_NORETURN (dds_reader,
                         DataReader_type (the_reader));
       return dds_reader._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed (
       ::DDSDataReader* the_reader,
       const ::DDS_RequestedDeadlineMissedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::RequestedDeadlineMissedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_requested_deadline_missed (
         this->get_datareader_proxy (the_reader),
         ddsstatus);
-#else
-      this->impl_->on_requested_deadline_missed (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos (
       ::DDSDataReader* the_reader,
       const ::DDS_RequestedIncompatibleQosStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::RequestedIncompatibleQosStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_requested_incompatible_qos (
         this->get_datareader_proxy (the_reader),
         ddsstatus);
-#else
-      this->impl_->on_requested_incompatible_qos (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected (
       ::DDSDataReader* the_reader,
       const ::DDS_SampleRejectedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::SampleRejectedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_sample_rejected (
         this->get_datareader_proxy (the_reader),
         ddsstatus);
-#else
-      this->impl_->on_sample_rejected (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed (
       ::DDSDataReader* the_reader,
       const ::DDS_LivelinessChangedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::LivelinessChangedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_liveliness_changed (
         this->get_datareader_proxy (the_reader),
         ddsstatus);
-#else
-      this->impl_->on_liveliness_changed (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available (
       ::DDSDataReader* the_reader)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_available");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available");
 
       this->impl_->on_data_available (
         this->get_datareader_proxy (the_reader));
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched (
       ::DDSDataReader* the_reader,
       const ::DDS_SubscriptionMatchedStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::SubscriptionMatchedStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_subscription_matched (
         this->get_datareader_proxy (the_reader),
         ddsstatus);
-#else
-      this->impl_->on_subscription_matched (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost (
       ::DDSDataReader* the_reader,
       const ::DDS_SampleLostStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::SampleLostStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_sample_lost (
-        this->get_datareader_proxy (the_reader),
-        ddsstatus);
-#else
-      this->impl_->on_sample_lost (
-        this->get_datareader_proxy (the_reader),
-        status);
-#endif
+        this->get_datareader_proxy (the_reader), ddsstatus);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SubscriberListener_ptr
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE>::get_subscriber_listener (void)
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_subscriber_listener (void)
     {
       return ::DDS::SubscriberListener::_duplicate (this->impl_.in ());
     }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h
index 2e5f2016e05..4952a98d528 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h
@@ -35,15 +35,15 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T :
       public virtual ::DDSSubscriberListener
     {
-    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE> Subscriber_type;
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
+    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Subscriber_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
     public:
       /// Constructor
       CCM_DDS_SubscriberListener_T ( ::DDS::SubscriberListener_ptr s);
diff --git a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
index d4b95f4f7ee..3368e7e1a05 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
@@ -13,39 +13,35 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_TopicListener_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_TopicListener_T (
         ::DDS::TopicListener_ptr p)
       : impl_ (::DDS::TopicListener::_duplicate (p))
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_TopicListener_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_TopicListener_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE>::on_inconsistent_topic (
+    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_inconsistent_topic (
       ::DDSTopic* the_topic,
       const ::DDS_InconsistentTopicStatus & status)
     {
       ::DDS::Topic_var dds_topic = ::DDS::Topic::_nil ();
       ACE_NEW (dds_topic,
                Topic_type (the_topic));
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS::InconsistentTopicStatus ddsstatus;
       ddsstatus <<= status;
       this->impl_->on_inconsistent_topic (dds_topic.in (), ddsstatus);
-#else
-      this->impl_->on_inconsistent_topic (dds_topic.in (), status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicListener_ptr
-    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE>::get_topiclistener (void)
+    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_topiclistener (void)
     {
       return ::DDS::TopicListener::_duplicate (this->impl_.in ());
     }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h
index ce61e216e44..132f5c6351d 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h
@@ -29,11 +29,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_TopicListener_T :
       public virtual ::DDSTopicListener
     {
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
     public:
       /// Constructor
       CCM_DDS_TopicListener_T (::DDS::TopicListener_ptr p);
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp
index 2cac29b1e83..5bf4cbd4e92 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp
@@ -6,8 +6,8 @@
 #include "ace/Tokenizer_T.h"
 #include "ace/Env_Value_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::DDS_Base_Connector_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DDS_Base_Connector_T (void)
   : domain_id_ (0)
   , configuration_complete_ (false)
   , library_name_ (0)
@@ -17,26 +17,26 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::DDS_Base_Connector_T (void)
   this->domain_id_ = id;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::~DDS_Base_Connector_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DDS_Base_Connector_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::DomainId_t
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::domain_id (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::domain_id (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::domain_id");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::domain_id");
 
   return this->domain_id_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::domain_id (
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::domain_id (
   ::DDS::DomainId_t domain_id)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::domain_id");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::domain_id");
 
   if (this->configuration_complete_)
     {
@@ -48,21 +48,21 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::domain_id (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 char *
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::qos_profile (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::qos_profile (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::qos_profile");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::qos_profile");
 
   return CORBA::string_dup (this->qos_profile_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::qos_profile (
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::qos_profile (
   const char * qos_profile)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::qos_profile");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::qos_profile");
 
   if (this->configuration_complete_)
     {
@@ -74,9 +74,9 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::qos_profile (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::init_default_domain (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::init_default_domain (void)
 {
   DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "DDS_Base_Connector_T::init_default_domain - "
                 "Configuring default domain <%d>\n",
@@ -143,12 +143,12 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::init_default_domain (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::set_session_context (
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_session_context (
   ::Components::SessionContext_ptr ctx)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::set_session_context");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_session_context");
 
   typename CCM_TYPE::context_type::_var_type lctx =
     CCM_TYPE::context_type::_narrow (ctx);
@@ -161,20 +161,20 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::set_session_context (
   this->context_ = lctx;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::configuration_complete (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete");
   this->init_default_domain ();
   this->configuration_complete_ = true;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_activate (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_activate (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_activate");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_activate");
   try
     {
       if (::CORBA::is_nil (this->domainparticipantlistener_.in ()))
@@ -197,11 +197,11 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_activate (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_passivate (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_passivate (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_passivate");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_passivate");
   try
     {
       this->domain_participant_->set_listener (
@@ -218,11 +218,11 @@ DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_passivate (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_remove (void)
+DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_remove (void)
 {
-  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_remove");
+  DDS4CCM_TRACE ("DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_remove");
 
   ::DDS::ReturnCode_t const retcode = this->dp_factory_.delete_participant (
                                   this->domain_participant_.in ());
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
index 409b8b5c585..82f1e98f50f 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
@@ -12,14 +12,14 @@
 #include "dds4ccm/impl/DomainParticipantListener_T.h"
 #include "dds4ccm/impl/DomainParticipantFactory_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Base_Connector_T
   : public virtual CCM_TYPE::base_type,
     public virtual ::CORBA::LocalObject,
     private virtual ACE_Copy_Disabled
 {
-typedef ::CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE> DomainParticipantListener;
-typedef ::CIAO::DDS4CCM::CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE> DomainParticipantFactory;
+typedef ::CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipantListener;
+typedef ::CIAO::DDS4CCM::CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipantFactory;
 
 public:
   DDS_Base_Connector_T (void);
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.cpp
index a21f0bc36f2..0cb3ebad143 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.cpp
@@ -12,8 +12,8 @@
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Event_Connector_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_Event_Connector_T (void) :
     TopicBaseConnector (),
     supplier_obtained_ (false),
     push_consumer_obtained_ (false),
@@ -24,154 +24,154 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Event_Connector_T (void) :
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_Event_Connector_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_Event_Connector_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::writer_type::_ptr_type
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_supplier_data (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_supplier_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_supplier_data");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_supplier_data");
 
   this->supplier_obtained_ = true;
   return this->supplier_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataWriter_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_supplier_dds_entity (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_supplier_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_supplier_dds_entity");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_supplier_dds_entity");
 
   this->supplier_obtained_ = true;
   return this->supplier_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::getter_type::_ptr_type
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_fresh_data (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_fresh_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_fresh_data");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_fresh_data");
 
   this->pull_consumer_obtained_ = true;
   return this->pull_consumer_.get_fresh_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_data (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_data");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_data");
 
   this->push_consumer_obtained_ = true;
   return this->push_consumer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_data (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_data");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_data");
 
   this->pull_consumer_obtained_ = true;
   return this->pull_consumer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_filter_config (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_filter_config");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_filter_config");
 
   this->pull_consumer_obtained_ = true;
   return this->pull_consumer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_DataListenerControl_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_data_control (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_data_control (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_data_control");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_data_control");
 
   this->push_consumer_obtained_ = true;
   return this->push_consumer_.get_data_control ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_dds_entity (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_consumer_dds_entity");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_consumer_dds_entity");
 
   this->pull_consumer_obtained_ = true;
   return this->pull_consumer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_consumer_filter (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_consumer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_consumer_filter");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_consumer_filter");
 
   return this->pull_consumer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_consumer_filter (
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_consumer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_consumer_filter");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_consumer_filter");
 
   this->pull_consumer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_dds_entity (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_dds_entity");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_dds_entity");
 
   this->push_consumer_obtained_ = true;
   return this->push_consumer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_filter_config (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_consumer_filter_config");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_consumer_filter_config");
 
   this->push_consumer_obtained_ = true;
   return this->push_consumer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_consumer_filter (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_consumer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_consumer_filter");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_consumer_filter");
 
   return this->push_consumer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_consumer_filter (
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_consumer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_consumer_filter");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_consumer_filter");
 
   this->push_consumer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete");
 
   TopicBaseConnector::configuration_complete ();
 
@@ -190,7 +190,7 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
   if (this->push_consumer_obtained_)
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "Creating push consumer port.\n"));
       this->push_consumer_.configuration_complete (
         this,
@@ -202,14 +202,14 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
   else
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "No need to create push consumer port.\n"));
     }
 
   if (this->supplier_obtained_)
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "Creating supplier port.\n"));
       this->supplier_.configuration_complete(
         this,
@@ -221,14 +221,14 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
   else
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "No need to create supplier port.\n"));
     }
 
   if (this->pull_consumer_obtained_)
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "Creating pull consumer port.\n"));
       this->pull_consumer_.configuration_complete (
         this,
@@ -240,16 +240,16 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
   else
     {
       DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO
-                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete - "
+                    "DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete - "
                     "No need to create pull consumer port.\n"));
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_activate (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_activate");
   ACE_Reactor* reactor = 0;
 #if (CIAO_DDS4CCM_CONTEXT_SWITCH == 1)
   reactor = this->context_->get_CCM_object()->_get_orb ()->orb_core ()->reactor ();
@@ -277,11 +277,11 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_passivate (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_passivate");
 
   if (this->push_consumer_obtained_)
     {
@@ -300,11 +300,11 @@ DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate (void)
   TopicBaseConnector::ccm_passivate ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_remove (void)
+DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_remove (void)
 {
-  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_remove");
+  DDS4CCM_TRACE ("DDS_Event_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_remove");
 
   if (this->push_consumer_obtained_)
     {
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.h
index 51107d60e3a..2b27000b0c6 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Event_Connector_T.h
@@ -13,9 +13,9 @@
 #include "dds4ccm/impl/DDS_Write_T.h"
 #include "dds4ccm/impl/DDS_Listen_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Event_Connector_T
-  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>
+  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
 {
 public:
   DDS_Event_Connector_T (void);
@@ -86,24 +86,24 @@ private:
    * DDS_Write supplier
    */
   //@{
-  DDS_Write_T <DDS_TYPE, CCM_TYPE> supplier_;
+  DDS_Write_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE> supplier_;
   //@}
 
   /**
    * DDS_Listen push_consumer
    */
   //@{
-  DDS_Listen_T <DDS_TYPE, CCM_TYPE, FIXED> push_consumer_;
+  DDS_Listen_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> push_consumer_;
   //@}
 
   /**
    * DDS_Get pull_consumer
    */
   //@{
-  DDS_Get_T <DDS_TYPE, CCM_TYPE, FIXED> pull_consumer_;
+  DDS_Get_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> pull_consumer_;
   //@}
 
- typedef DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE> TopicBaseConnector;
+ typedef DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> TopicBaseConnector;
 };
 
 #include "dds4ccm/impl/DDS_Event_Connector_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Get_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Get_T.cpp
index 90a2d194735..9bd3ab3ced6 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Get_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Get_T.cpp
@@ -3,26 +3,26 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Get_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_Get_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_Get_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_Get_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (
+DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete (
   typename CCM_TYPE::base_type::_ptr_type component,
   ::DDS::Topic_ptr topic,
   ::DDS::Subscriber_ptr subscriber,
   const char* library_name,
   const char* profile_name)
 {
-  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete");
   if (DDSSubscriberBase::configuration_complete(component,
                                                 topic,
                                                 subscriber,
@@ -35,21 +35,21 @@ DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (
   return true;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::remove (
+DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::remove (
   ::DDS::Subscriber_ptr subscriber)
 {
-  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::remove");
+  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::remove");
   DDSSubscriberBase::remove (subscriber);
   this->dds_get_._set_component (CCM_TYPE::base_type::_nil ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::getter_type::_ptr_type
-DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::get_fresh_data (void)
+DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_fresh_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED>::get_fresh_data");
+  DDS4CCM_TRACE ("DDS_Get_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_fresh_data");
 
   return CCM_TYPE::getter_type::_duplicate (&this->dds_get_);
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Get_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Get_T.h
index 9a634c36c5a..168dee4f5d4 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Get_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Get_T.h
@@ -11,9 +11,9 @@
 #include "dds4ccm/impl/DDS_Subscriber_Base_T.h"
 #include "dds4ccm/impl/Getter_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Get_T
-  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>
+  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>
 {
 public:
   DDS_Get_T (void);
@@ -43,9 +43,9 @@ private:
    */
   //@{
   ::DDS::DataReaderListener_var listener_;
-  ::CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, FIXED> dds_get_;
+  ::CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> dds_get_;
   //@}
-  typedef DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED> DDSSubscriberBase;
+  typedef DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> DDSSubscriberBase;
 };
 
 #include "dds4ccm/impl/DDS_Get_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.cpp
index e61deac1922..fba7d161734 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.cpp
@@ -5,26 +5,26 @@
 #include "dds4ccm/impl/DataReaderListener_T.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Listen_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_Listen_T (void) :
   data_control_ (new CCM_DDS_DataListenerControl_T
     < ::CCM_DDS::CCM_DataListenerControl> ())
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_Listen_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_Listen_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
+DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate (
   typename CCM_TYPE::listener_type::_ptr_type listener,
   ::CCM_DDS::PortStatusListener_ptr status,
   ACE_Reactor* reactor)
 {
-  DDS4CCM_TRACE ("DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate");
+  DDS4CCM_TRACE ("DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate");
   try
     {
       if (::CORBA::is_nil (this->listener_.in ()))
@@ -48,11 +48,11 @@ DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_DataListenerControl_ptr
-DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data_control (void)
+DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data_control (void)
 {
-  DDS4CCM_TRACE ("DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data_control");
+  DDS4CCM_TRACE ("DDS_Listen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data_control");
 
   return ::CCM_DDS::CCM_DataListenerControl::_duplicate (this->data_control_.in ());
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.h
index f47abe59459..09f56b0ed2b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Listen_T.h
@@ -16,9 +16,9 @@ ACE_END_VERSIONED_NAMESPACE_DECL
 
 
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Listen_T
-  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>
+  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>
 {
 public:
   DDS_Listen_T (void);
@@ -44,7 +44,7 @@ private:
   //@{
   ::CCM_DDS::CCM_DataListenerControl_var data_control_;
   //@}
-  typedef ::CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE> DataReaderListener;
+  typedef ::CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReaderListener;
 };
 
 #include "dds4ccm/impl/DDS_Listen_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Read_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Read_T.cpp
index da85c353df2..26c503c52c7 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Read_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Read_T.cpp
@@ -3,13 +3,13 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Read_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Read_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Read_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_Read_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Read_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_Read_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Read_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_Read_T (void)
 {
 }
 
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Read_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Read_T.h
index a94aa3d3117..e5b02563d55 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Read_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Read_T.h
@@ -10,9 +10,9 @@
 
 #include "dds4ccm/impl/DDS_Subscriber_Base_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Read_T
-  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>
+  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>
 {
 public:
   DDS_Read_T (void);
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.cpp
index 14478628577..b1046758d02 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.cpp
@@ -8,26 +8,26 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_StateListen_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_StateListen_T (void) :
   data_control_ (new CCM_DDS_StateListenerControl_T
     < ::CCM_DDS::CCM_StateListenerControl> ())
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_StateListen_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_StateListen_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
+DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate (
   typename CCM_TYPE::statelistener_type::_ptr_type listener,
   ::CCM_DDS::PortStatusListener_ptr status,
   ACE_Reactor* reactor)
 {
-  DDS4CCM_TRACE ("DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate");
+  DDS4CCM_TRACE ("DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate");
 
   try
     {
@@ -52,11 +52,11 @@ DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_StateListenerControl_ptr
-DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data_control (void)
+DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data_control (void)
 {
-  DDS4CCM_TRACE ("DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data_control");
+  DDS4CCM_TRACE ("DDS_StateListen_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data_control");
 
   return ::CCM_DDS::CCM_StateListenerControl::_duplicate (
     this->data_control_.in ());
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.h b/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.h
index 35b4f995aa9..94217fa100b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_StateListen_T.h
@@ -10,9 +10,9 @@
 
 #include "dds4ccm/impl/DDS_Subscriber_Base_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_StateListen_T
-  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>
+  : public DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>
 {
 public:
   DDS_StateListen_T (void);
@@ -38,7 +38,7 @@ private:
   //@{
   ::CCM_DDS::CCM_StateListenerControl_var data_control_;
   //@}
-  typedef ::CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE> DataReaderStateListener;
+  typedef ::CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReaderStateListener;
 };
 
 #include "dds4ccm/impl/DDS_StateListen_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
index 80dcfa59cfc..03662cdf8ce 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
@@ -14,8 +14,8 @@
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_State_Connector_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_State_Connector_T (void) :
     TopicBaseConnector (),
     observable_obtained_ (false),
     passive_observer_obtained_ (false),
@@ -25,262 +25,262 @@ DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_State_Connector_T (void) :
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_State_Connector_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_State_Connector_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::updater_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_observable_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_observable_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_observable_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_observable_data");
 
   this->observable_obtained_ = true;
   return this->observable_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataWriter_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_observable_dds_entity (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_observable_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_observable_dds_entity");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_observable_dds_entity");
 
   this->observable_obtained_ = true;
   return this->observable_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_data");
 
   this->passive_observer_obtained_ = true;
   return this->passive_observer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_dds_entity (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_dds_entity");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_dds_entity");
 
   this->passive_observer_obtained_ = true;
   return this->passive_observer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_filter_config (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_passive_observer_filter_config");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_passive_observer_filter_config");
 
   this->passive_observer_obtained_ = true;
   return this->passive_observer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::passive_observer_filter (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passive_observer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::passive_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passive_observer_filter");
 
   return this->passive_observer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::passive_observer_filter (
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passive_observer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::passive_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passive_observer_filter");
 
   this->passive_observer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_data");
 
   this->pull_observer_obtained_ = true;
   return this->pull_observer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::getter_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_fresh_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_fresh_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_fresh_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_fresh_data");
 
   this->pull_observer_obtained_ = true;
   return this->pull_observer_.get_fresh_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_dds_entity (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_dds_entity");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_dds_entity");
 
   this->pull_observer_obtained_ = true;
   return this->pull_observer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_filter_config (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_pull_observer_filter_config");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_pull_observer_filter_config");
 
   this->pull_observer_obtained_ = true;
   return this->pull_observer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_observer_filter (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_observer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_observer_filter");
 
   return this->pull_observer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_observer_filter (
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_observer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::pull_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::pull_observer_filter");
 
   this->pull_observer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_data");
 
   this->push_observer_obtained_ = true;
   return this->push_observer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_DataListenerControl_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_data_control (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_data_control (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_data_control");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_data_control");
 
   this->push_observer_obtained_ = true;
   return this->push_observer_.get_data_control ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_dds_entity (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_dds_entity");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_dds_entity");
 
   this->push_observer_obtained_ = true;
   return this->push_observer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_filter_config (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_observer_filter_config");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_observer_filter_config");
 
   this->push_observer_obtained_ = true;
   return this->push_observer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_observer_filter (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_observer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_observer_filter");
 
   return this->push_observer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_observer_filter (
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_observer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_observer_filter");
 
   this->push_observer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_data (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_data (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_data");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_data");
 
   this->push_state_observer_obtained_ = true;
   return this->push_state_observer_.get_data ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_StateListenerControl_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_data_control (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_data_control (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_data_control");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_data_control");
 
   this->push_state_observer_obtained_ = true;
   return this->push_state_observer_.get_data_control ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_dds_entity (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_dds_entity");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_dds_entity");
 
   this->push_state_observer_obtained_ = true;
   return this->push_state_observer_.get_dds_entity ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_filter_config (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::get_push_state_observer_filter_config");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_push_state_observer_filter_config");
 
   this->push_state_observer_obtained_ = true;
   return this->push_state_observer_.get_filter_config ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter*
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_state_observer_filter (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_state_observer_filter (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_state_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_state_observer_filter");
 
   return this->push_state_observer_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_state_observer_filter (
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_state_observer_filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::push_state_observer_filter");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::push_state_observer_filter");
 
   this->push_state_observer_.filter (filter);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete");
 
   TopicBaseConnector::configuration_complete ();
 
@@ -357,11 +357,11 @@ DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_activate (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_activate");
 
   ACE_Reactor* reactor = 0;
 #if (CIAO_DDS4CCM_CONTEXT_SWITCH == 1)
@@ -405,11 +405,11 @@ DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_activate (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_passivate (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_passivate");
   if (this->observable_obtained_)
     {
       this->observable_.passivate ();
@@ -438,11 +438,11 @@ DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_passivate (void)
   TopicBaseConnector::ccm_passivate ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_remove (void)
+DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_remove (void)
 {
-  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED>::ccm_remove");
+  DDS4CCM_TRACE ("DDS_State_Connector_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::ccm_remove");
 
   if (this->observable_obtained_)
     {
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.h
index c87044ae7d2..0930c323717 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.h
@@ -15,9 +15,9 @@
 #include "dds4ccm/impl/DDS_Update_T.h"
 #include "dds4ccm/impl/DDS_Read_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_State_Connector_T
-  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>
+  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
 {
 public:
   DDS_State_Connector_T (void);
@@ -132,38 +132,38 @@ private:
    * DDS_Update observable
    */
   //@{
-  DDS_Update_T <DDS_TYPE, CCM_TYPE> observable_;
+  DDS_Update_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE> observable_;
   //@}
 
   /**
    * DDS_Read passive_observer
    */
   //@{
-  DDS_Read_T <DDS_TYPE, CCM_TYPE, FIXED> passive_observer_;
+  DDS_Read_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> passive_observer_;
   //@}
 
   /**
    * DDS_Get pull_observer
    */
   //@{
-  DDS_Get_T <DDS_TYPE, CCM_TYPE, FIXED> pull_observer_;
+  DDS_Get_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> pull_observer_;
   //@}
 
   /**
    * DDS_Listen push_observer
    */
   //@{
-  DDS_Listen_T <DDS_TYPE, CCM_TYPE, FIXED> push_observer_;
+  DDS_Listen_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> push_observer_;
   //@}
 
   /**
    * DDS_StateListen push_state_observer
    */
   //@{
-  DDS_StateListen_T <DDS_TYPE, CCM_TYPE, FIXED> push_state_observer_;
+  DDS_StateListen_T <DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> push_state_observer_;
   //@}
 
-typedef DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE> TopicBaseConnector;
+typedef DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> TopicBaseConnector;
 };
 
 #include "dds4ccm/impl/DDS_State_Connector_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
index 46859c2f4cd..6c6b94c689e 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
@@ -3,28 +3,28 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::DDS_Subscriber_Base_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::DDS_Subscriber_Base_T (void)
   : data_reader_ (0),
     configuration_complete_ (false)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::~DDS_Subscriber_Base_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~DDS_Subscriber_Base_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete (
   typename CCM_TYPE::base_type::_ptr_type component,
   ::DDS::Topic_ptr topic,
   ::DDS::Subscriber_ptr subscriber,
   const char* library_name,
   const char* profile_name)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::configuration_complete");
 
   this->configuration_complete_ = true;
 
@@ -85,13 +85,13 @@ DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::configuration_complete (
   return false;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate (
   ::CCM_DDS::PortStatusListener_ptr status,
   ACE_Reactor* reactor)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::activate");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::activate");
 
   try
     {
@@ -113,11 +113,11 @@ DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::activate (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::passivate ()
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passivate ()
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::passivate");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::passivate");
 
   try
     {
@@ -132,12 +132,12 @@ DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::passivate ()
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::remove (
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::remove (
   ::DDS::Subscriber_ptr subscriber)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::remove");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::remove");
 
   try
     {
@@ -153,48 +153,48 @@ DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::remove (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::reader_type::_ptr_type
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data (void)
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_data");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_data");
 
   return CCM_TYPE::reader_type::_duplicate (&this->dds_read_);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataReader_ptr
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_dds_entity (void)
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_dds_entity");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_dds_entity");
 
   return ::DDS::CCM_DataReader::_duplicate (&this->data_reader_);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::CCM_ContentFilterSetting_ptr
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_filter_config (void)
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_filter_config (void)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::get_filter_config");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_filter_config");
 
   return ::CCM_DDS::CCM_ContentFilterSetting::_duplicate (&this->cft_setting_);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter *
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::filter (void)
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::filter (void)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::filter");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::filter");
 
   return this->cft_setting_.filter ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::filter (
+DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::filter (
   const ::CCM_DDS::QueryFilter & filter)
 {
-  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED>::filter");
+  DDS4CCM_TRACE ("DDS_Subscriber_Base_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::filter");
   if (this->configuration_complete_)
     {
       throw ::CCM_DDS::NonChangeable ();
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
index 1ad0122a183..297c5914cdc 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
@@ -16,7 +16,7 @@
 #include "dds4ccm/impl/ContentFilterSetting.h"
 #include "dds4ccm/impl/ContentFilteredTopic_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Subscriber_Base_T
 {
 public:
@@ -61,12 +61,12 @@ protected:
   //@{
   ::DDS::DataReaderListener_var listener_;
   ::CIAO::DDS4CCM::CCM_DDS_ContentFilterSetting_i cft_setting_;
-  ::CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED> dds_read_;
-  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> data_reader_;
+  ::CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE> dds_read_;
+  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> data_reader_;
   bool configuration_complete_;
   //@}
 private:
-  typedef ::CIAO::DDS4CCM::PortStatusListener_T <DDS_TYPE, CCM_TYPE> PortStatusListener;
+  typedef ::CIAO::DDS4CCM::PortStatusListener_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE> PortStatusListener;
 };
 
 #include "dds4ccm/impl/DDS_Subscriber_Base_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
index 039ad0941e3..5a2350fb4cd 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
@@ -3,75 +3,75 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::DDS_TopicBase_Connector_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DDS_TopicBase_Connector_T (void) :
     BaseConnector ()
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::~DDS_TopicBase_Connector_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DDS_TopicBase_Connector_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::configuration_complete (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete (void)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete");
   BaseConnector::configuration_complete ();
   this->init_default_topic ();
   this->init_subscriber ();
   this->init_publisher ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_activate (ACE_Reactor* reactor)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_activate (ACE_Reactor* reactor)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_activate");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_activate");
   BaseConnector::ccm_activate ();
   this->activate_default_topic (reactor);
   this->activate_subscriber (reactor);
   this->activate_publisher (reactor);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_passivate (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_passivate (void)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_passivate");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_passivate");
   this->passivate_default_topic ();
   this->passivate_subscriber ();
   this->passivate_publisher ();
   BaseConnector::ccm_passivate ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_remove (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_remove (void)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::ccm_remove");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ccm_remove");
   this->remove_default_topic ();
   this->remove_subscriber ();
   this->remove_publisher ();
   BaseConnector::ccm_remove ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 char *
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::topic_name (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::topic_name (void)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::topic_name");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::topic_name");
   return CORBA::string_dup (this->topic_name_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::topic_name (
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::topic_name (
   const char * topic_name)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::topic_name");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::topic_name");
   if (this->configuration_complete_)
     {
       throw ::CCM_DDS::NonChangeable ();
@@ -82,12 +82,12 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::topic_name (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields (
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::key_fields (
   const ::DDS::StringSeq & key_fields)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::key_fields");
   if (this->configuration_complete_)
     {
       throw ::CCM_DDS::NonChangeable ();
@@ -102,11 +102,11 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StringSeq *
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::key_fields (void)
 {
-  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields");
+  DDS4CCM_TRACE ("DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::key_fields");
 /*
     For future use, DDS_TYPE doesn't have get_typecode yet
     ::DDS_TypeCode* ptr = ::DDS_TYPE::type_support::get_typecode ();
@@ -134,9 +134,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::key_fields (void)
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_default_topic (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::init_default_topic (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::init_default_topic");
 
@@ -144,8 +144,8 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_default_topic (void)
     {
       try
         {
-          ::CIAO::DDS4CCM::CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> *part =
-            dynamic_cast< CIAO::DDS4CCM::CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> * > (
+          ::CIAO::DDS4CCM::CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *part =
+            dynamic_cast< CIAO::DDS4CCM::CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * > (
               this->domain_participant_.in ());
           DDS_ReturnCode_t const retcode = DDS_TYPE::type_support::register_type(
             part->get_impl (), DDS_TYPE::type_support::get_type_name ());
@@ -189,9 +189,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_default_topic (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_subscriber (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::init_subscriber (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::init_subscriber");
 
@@ -227,9 +227,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_subscriber (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_publisher (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::init_publisher (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::init_publisher");
 
@@ -256,9 +256,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::init_publisher (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_default_topic (ACE_Reactor* reactor)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate_default_topic (ACE_Reactor* reactor)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::activate_default_topic");
   try
@@ -284,9 +284,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_default_topic (ACE_React
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_subscriber (ACE_Reactor* reactor)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate_subscriber (ACE_Reactor* reactor)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::activate_subscriber");
 
@@ -313,9 +313,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_subscriber (ACE_Reactor*
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_publisher (ACE_Reactor* reactor)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate_publisher (ACE_Reactor* reactor)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::activate_publisher");
 
@@ -342,9 +342,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::activate_publisher (ACE_Reactor*
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_default_topic (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate_default_topic (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::passivate_default_topic");
 
@@ -364,9 +364,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_default_topic (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_subscriber (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate_subscriber (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::passivate_subscriber");
 
@@ -385,9 +385,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_subscriber (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_publisher (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate_publisher (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::passivate_publisher");
 
@@ -406,9 +406,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::passivate_publisher (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::remove_default_topic (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove_default_topic (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::remove_default_topic");
 
@@ -434,9 +434,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::remove_default_topic (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::remove_subscriber (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove_subscriber (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::remove_subscriber");
 
@@ -453,9 +453,9 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::remove_subscriber (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>::remove_publisher (void)
+DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove_publisher (void)
 {
   DDS4CCM_TRACE ("DDS_TopicBase_Connector_T::remove_publisher");
 
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
index c4ebac3dc01..01e6ae7b977 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
@@ -15,9 +15,9 @@
 #include "dds4ccm/impl/PublisherListener_T.h"
 #include "dds4ccm/impl/SubscriberListener_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_TopicBase_Connector_T
-  : public virtual DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE>
+  : public virtual DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
 {
 public:
   DDS_TopicBase_Connector_T (void);
@@ -64,10 +64,10 @@ protected:
   ::DDS::Subscriber_var subscriber_;
   ::DDS::SubscriberListener_var subscriber_listener_;
 
-  typedef ::CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE> TopicListener;
-  typedef ::CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE> SubscriberListener;
-  typedef ::CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE> PublisherListener;
-  typedef DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE> BaseConnector;
+  typedef ::CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> TopicListener;
+  typedef ::CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> SubscriberListener;
+  typedef ::CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> PublisherListener;
+  typedef DDS_Base_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> BaseConnector;
 };
 
 #include "dds4ccm/impl/DDS_TopicBase_Connector_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
index ca81f87c64b..cd633bd5e3b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
@@ -8,27 +8,27 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::DDS_Update_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DDS_Update_T (void) :
   ccm_dds_writer_ (0)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::~DDS_Update_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DDS_Update_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete (
   typename CCM_TYPE::base_type::_ptr_type component,
   ::DDS::Topic_ptr topic,
   ::DDS::Publisher_ptr publisher,
   const char* library_name,
   const char* profile_name)
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete");
   if (!this->ccm_dds_writer_.get_impl ())
     {
       try
@@ -52,8 +52,8 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
                   ::DDS::DataWriterListener::_nil (),
                   0);
             }
-          ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>  *rw =
-            dynamic_cast < ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> *> (dwv_tmp.in ());
+          ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>  *rw =
+            dynamic_cast < ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *> (dwv_tmp.in ());
           this->ccm_dds_writer_.set_impl (rw->get_impl ());
           //TODO
           this->dds_update_.set_impl (&this->ccm_dds_writer_);
@@ -67,11 +67,11 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::activate ()
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate ()
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE>::activate");
+  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate");
   try
     {
       if (::CORBA::is_nil (this->data_listener_.in ()))
@@ -92,11 +92,11 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE>::activate ()
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::passivate ()
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate ()
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE>::passivate");
+  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate");
   try
     {
       this->ccm_dds_writer_.set_listener (
@@ -112,12 +112,12 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE>::passivate ()
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::remove (
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove (
   ::DDS::Publisher_ptr publisher)
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE>::remove");
+  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove");
   try
     {
       ::DDS::ReturnCode_t const retval =
@@ -141,16 +141,16 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE>::remove (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::updater_type::_ptr_type
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::get_data (void)
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_data (void)
 {
   return CCM_TYPE::updater_type::_duplicate (&this->dds_update_);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataWriter_ptr
-DDS_Update_T<DDS_TYPE, CCM_TYPE>::get_dds_entity (void)
+DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity (void)
 {
   return ::DDS::CCM_DataWriter::_duplicate (&this->ccm_dds_writer_);
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h
index d2d2c8dc24d..89742555286 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h
@@ -10,7 +10,7 @@
 
 #include "dds4ccm/impl/Updater_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Update_T
 {
 public:
@@ -40,10 +40,10 @@ private:
    */
   //@{
   ::DDS::DataWriterListener_var data_listener_;
-  ::CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE> dds_update_;
-  ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> ccm_dds_writer_;
+  ::CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> dds_update_;
+  ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ccm_dds_writer_;
   //@}
-  typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE> DataWriterListener;
+  typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriterListener;
 };
 
 #include "dds4ccm/impl/DDS_Update_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
index 3b9678a6f95..fd6bef40a10 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
@@ -7,27 +7,27 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::DDS_Write_T (void) :
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DDS_Write_T (void) :
   ccm_dds_writer_ (0)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::~DDS_Write_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DDS_Write_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete (
   typename CCM_TYPE::base_type::_ptr_type component,
   ::DDS::Topic_ptr topic,
   ::DDS::Publisher_ptr publisher,
   const char* library_name,
   const char* profile_name)
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::configuration_complete");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::configuration_complete");
 
   try
     {
@@ -52,8 +52,8 @@ DDS_Write_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
                   ::DDS::DataWriterListener::_nil (),
                   0);
              }
-          ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> *rw =
-            dynamic_cast < ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> *>
+          ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *rw =
+            dynamic_cast < ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *>
               (dwv_tmp.in ());
           this->ccm_dds_writer_.set_impl (rw->get_impl ());
           this->writer_t_.set_impl (&this->ccm_dds_writer_);
@@ -66,11 +66,11 @@ DDS_Write_T<DDS_TYPE, CCM_TYPE>::configuration_complete (
       throw CORBA::INTERNAL ();
     }
 }
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::activate ()
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate ()
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::activate");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::activate");
   try
     {
       if (::CORBA::is_nil (this->data_listener_.in ()))
@@ -90,11 +90,11 @@ DDS_Write_T<DDS_TYPE, CCM_TYPE>::activate ()
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::passivate ()
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate ()
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::passivate");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate");
   try
     {
       this->ccm_dds_writer_.set_listener (
@@ -109,12 +109,12 @@ DDS_Write_T<DDS_TYPE, CCM_TYPE>::passivate ()
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::remove (
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove (
   ::DDS::Publisher_ptr publisher)
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::remove");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove");
   try
     {
       DDS::ReturnCode_t const retval =
@@ -139,20 +139,20 @@ DDS_Write_T<DDS_TYPE, CCM_TYPE>::remove (
 }
 
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename CCM_TYPE::writer_type::_ptr_type
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::get_data (void)
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::get_data");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_data");
 
   return CCM_TYPE::writer_type::_duplicate (&this->writer_t_);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataWriter_ptr
-DDS_Write_T<DDS_TYPE, CCM_TYPE>::get_dds_entity (void)
+DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE>::get_dds_entity");
+  DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity");
 
   return ::DDS::CCM_DataWriter::_duplicate (&this->ccm_dds_writer_);
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h
index 0f42014acba..42899016d60 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h
@@ -12,7 +12,7 @@
 #include "dds4ccm/impl/DataWriterListener_T.h"
 #include "dds4ccm/impl/Writer_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Write_T
 {
 public:
@@ -48,11 +48,11 @@ private:
    */
   //@{
   ::DDS::DataWriterListener_var data_listener_;
-  ::CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE> writer_t_;
-  ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> ccm_dds_writer_;
+  ::CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> writer_t_;
+  ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ccm_dds_writer_;
   //@}
 
-  typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE> DataWriterListener;
+  typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriterListener;
 };
 
 #include "dds4ccm/impl/DDS_Write_T.cpp"
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.cpp
index c37ec5d6598..1bb5dd5900d 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.cpp
@@ -3,9 +3,9 @@
 #include "dds4ccm/impl/Utils.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE>::DataReaderHandler_T (
-            typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>* drl,
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataReaderHandler_T (
+            typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl,
             ::DDS::DataReader_ptr dr)
       : drl_ (drl),
         dr_ (::DDS::DataReader::_duplicate (dr))
@@ -14,14 +14,14 @@ CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE>::DataReaderHandler_T (
     (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE>::~DataReaderHandler_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataReaderHandler_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 int
-CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE>::handle_exception (ACE_HANDLE)
+CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::handle_exception (ACE_HANDLE)
 {
   try
     {
@@ -33,9 +33,9 @@ CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE>::handle_exception (ACE_HA
   return 0;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE>::DataReaderStateHandler_T (
-            typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>* drl,
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataReaderStateHandler_T (
+            typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl,
             ::DDS::DataReader_ptr dr)
       : drl_ (drl),
         dr_ (::DDS::DataReader::_duplicate (dr))
@@ -44,14 +44,14 @@ CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE>::DataReaderStateHand
     (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE>::~DataReaderStateHandler_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataReaderStateHandler_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 int
-CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE>::handle_exception (ACE_HANDLE)
+CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::handle_exception (ACE_HANDLE)
 {
   try
     {
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.h b/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.h
index ff4306c1cf7..ce984a4cbbf 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderHandler_T.h
@@ -18,41 +18,41 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderHandler_T :
       public ACE_Event_Handler
     {
       public:
         DataReaderHandler_T (
-            typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>* drl,
+            typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl,
             ::DDS::DataReader_ptr dr);
         virtual ~DataReaderHandler_T ();
 
         virtual int handle_exception (ACE_HANDLE fc = ACE_INVALID_HANDLE);
       private:
-        typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>* drl_;
+        typename CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl_;
         ::DDS::DataReader_var dr_;
     };
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderStateListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderStateHandler_T :
       public ACE_Event_Handler
     {
       public:
         DataReaderStateHandler_T (
-            typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>* drl,
+            typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl,
             ::DDS::DataReader_ptr dr);
         virtual ~DataReaderStateHandler_T ();
 
         virtual int handle_exception (ACE_HANDLE fc = ACE_INVALID_HANDLE);
       private:
-        typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>* drl_;
+        typename CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>* drl_;
         ::DDS::DataReader_var dr_;
     };
   }
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
index eca6b1d2a80..cf99b7c00f5 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
@@ -4,28 +4,28 @@
 #include "dds4ccm/impl/Log_Macros.h"
 #include "ace/Reactor.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::DataReaderListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataReaderListener_T (
   typename CCM_TYPE::listener_type::_ptr_type listener,
   ::CCM_DDS::PortStatusListener_ptr port_status_listener,
   ::CCM_DDS::DataListenerControl_ptr control,
   ACE_Reactor* reactor)
-  : PortStatusListener_T <DDS_TYPE, CCM_TYPE> (port_status_listener, reactor) ,
+  : PortStatusListener_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE> (port_status_listener, reactor) ,
     listener_ (CCM_TYPE::listener_type::_duplicate (listener)),
     control_ (::CCM_DDS::DataListenerControl::_duplicate (control))
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderListener_T::DataReaderListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::~DataReaderListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataReaderListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderListener_T::~DataReaderListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (::DDS::DataReader_ptr rdr)
+CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available (::DDS::DataReader_ptr rdr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderListener_T::on_data_available");
 
@@ -52,9 +52,9 @@ CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (::DD
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_i (::DDS::DataReader_ptr rdr)
+CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available_i (::DDS::DataReader_ptr rdr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderListener_T::on_data_available_i");
 
@@ -65,8 +65,8 @@ CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_i (::
       return;
     }
 
-  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> * reader =
-    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> *> (rdr);
+  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * reader =
+    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *> (rdr);
 
   if (!reader)
     {
@@ -152,9 +152,9 @@ CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_i (::
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   ::CCM_DDS::PortStatusListener_ptr listener)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderListener_T::get_mask");
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.h b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.h
index c0b25b16fb8..960915f2d6c 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.h
@@ -22,9 +22,9 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderListener_T :
-      public PortStatusListener_T <DDS_TYPE, CCM_TYPE>
+      public PortStatusListener_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     {
     public:
       /// Constructor
@@ -48,8 +48,8 @@ namespace CIAO
       typename CCM_TYPE::listener_type::_var_type listener_;
       ::CCM_DDS::DataListenerControl_var control_;
 
-      typedef ::CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE> drh;
-      typedef ::CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE> PortStatusListener;
+      typedef ::CIAO::DDS4CCM::DataReaderHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> drh;
+      typedef ::CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> PortStatusListener;
     };
   }
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
index 5f13443f307..cd234735ff8 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
@@ -7,13 +7,13 @@
 
 #include <vector>
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::DataReaderStateListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataReaderStateListener_T (
   typename CCM_TYPE::statelistener_type::_ptr_type listener,
   ::CCM_DDS::PortStatusListener_ptr port_status_listener,
   ::CCM_DDS::StateListenerControl_ptr control,
   ACE_Reactor* reactor)
-  : PortStatusListener_T <DDS_TYPE, CCM_TYPE> (port_status_listener, reactor) ,
+  : PortStatusListener_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE> (port_status_listener, reactor) ,
     listener_ (CCM_TYPE::statelistener_type::_duplicate (listener)),
     control_ (::CCM_DDS::StateListenerControl::_duplicate (control))
 {
@@ -21,15 +21,15 @@ CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::DataReaderStateLis
 }
 
 // Implementation skeleton destructor
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::~DataReaderStateListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataReaderStateListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderStateListener_T::~DataReaderStateListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::on_data_available(::DDS::DataReader_ptr rdr)
+CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available(::DDS::DataReader_ptr rdr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderStateListener_T::on_data_available");
   if (::CORBA::is_nil (this->control_.in ()) ||
@@ -54,9 +54,9 @@ CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::on_data_available(
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_i (::DDS::DataReader_ptr rdr)
+CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available_i (::DDS::DataReader_ptr rdr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReaderStateListener_T::on_data_available_i");
 
@@ -67,8 +67,8 @@ CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_
       return;
     }
 
-  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> * reader =
-    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> *> (rdr);
+  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * reader =
+    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *> (rdr);
 
   if (!reader)
     {
@@ -225,9 +225,9 @@ CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::on_data_available_
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   typename CCM_TYPE::statelistener_type::_ptr_type listener)
 {
   if (! ::CORBA::is_nil (listener) || CIAO_debug_level >= 10)
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.h b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.h
index df98c3ba438..d8149e151e6 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.h
@@ -17,9 +17,9 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReaderStateListener_T :
-      public PortStatusListener_T <DDS_TYPE, CCM_TYPE>
+      public PortStatusListener_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     {
     public:
       /// Constructor
@@ -43,7 +43,7 @@ namespace CIAO
       typename CCM_TYPE::statelistener_type::_var_type listener_;
       ::CCM_DDS::StateListenerControl_var control_;
 
-      typedef ::CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE> drsh;
+      typedef ::CIAO::DDS4CCM::DataReaderStateHandler_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> drsh;
     };
   }
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp
index bb88f872e57..655bd989033 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp
@@ -25,8 +25,8 @@
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::DataReader_T (DDSDataReader * dr)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataReader_T (DDSDataReader * dr)
   : impl_ (0),
     rd_condition_ (0),
     ws_ (0),
@@ -42,17 +42,17 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::DataReader_T (DDSDataReader * d
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::~DataReader_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataReader_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::~DataReader_T");
   delete this->ws_;
   this->ws_ = 0;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_wo_instance (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::read_wo_instance (
   typename DDS_TYPE::dds_seq_type & data,
   ::DDS_SampleInfoSeq & sample_info)
 {
@@ -89,9 +89,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_wo_instance (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_w_instance (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::read_w_instance (
   typename DDS_TYPE::dds_seq_type & data,
   const ::DDS_InstanceHandle_t & lookup_hnd,
   DDS_SampleInfoSeq & sample_info)
@@ -122,9 +122,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_w_instance (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_w_condition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::read_w_condition (
   typename DDS_TYPE::dds_seq_type & data,
   ::DDS_SampleInfoSeq & sample_info,
   ::DDS_Long max_samples)
@@ -145,9 +145,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::read_w_condition (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::take (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::take (
   typename DDS_TYPE::dds_seq_type & data,
   ::DDS_SampleInfoSeq & sample_info,
   ::DDS_Long max_samples)
@@ -172,26 +172,26 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::take (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS_InstanceHandle_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::lookup_instance (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_instance (
   const typename DDS_TYPE::value_type& an_instance)
 {
   return this->impl ()->lookup_instance (an_instance);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::return_loan (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::return_loan (
   typename DDS_TYPE::dds_seq_type & data,
   ::DDS_SampleInfoSeq & sample_info)
 {
   return this->impl ()->return_loan (data, sample_info);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::query (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::query (void)
 {
   if (!this->qc_reader_)
     {
@@ -210,9 +210,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::query (void)
   return filter._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::query (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::query (
   const ::CCM_DDS::QueryFilter & filter)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::query");
@@ -269,9 +269,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::query (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_filter (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_filter (
   const ::CCM_DDS::QueryFilter & filter,
   DDSQueryCondition * qc)
 {
@@ -288,9 +288,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_filter (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDSReadCondition *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_readcondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_readcondition (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_readcondition");
   if (!this->rd_condition_)
@@ -303,9 +303,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_readcondition (void)
   return this->rd_condition_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_readcondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_readcondition (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::create_readcondition");
   if (!this->ws_)
@@ -325,17 +325,17 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_readcondition (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDSQueryCondition *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_querycondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_querycondition (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_querycondition");
   return this->qc_getter_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::attach_querycondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::attach_querycondition (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::attach_querycondition");
 
@@ -357,9 +357,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::attach_querycondition (void)
                                       "Query condition created and attached to Waitset.\n"));
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::wait (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::wait (
   DDSConditionSeq & active_conditions,
   DDS_Duration_t & time_out)
 {
@@ -375,9 +375,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::wait (
    return true;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::remove_condition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove_condition (
   DDSQueryCondition * qc,
   const char * type)
 {
@@ -400,9 +400,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::remove_condition (
 }
 
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::remove_conditions ()
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove_conditions ()
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::remove_conditions");
 
@@ -456,17 +456,17 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::remove_conditions ()
   this->ws_ = 0;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::passivate ()
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate ()
 {
   this->remove_conditions ();
   this->set_listener (::DDS::DataReaderListener::_nil (), 0);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_datareader (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
   ::DDS::ContentFilteredTopic_ptr topic,
   ::DDS::Subscriber_ptr subscriber,
   const char * library_name,
@@ -496,9 +496,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_datareader (
   this->set_impl(reader.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_datareader (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
   ::DDS::Topic_ptr topic,
   ::DDS::Subscriber_ptr subscriber,
   const char * library_name,
@@ -530,9 +530,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_datareader (
   this->set_impl (reader.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::delete_datareader (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader (
   ::DDS::Subscriber_ptr subscriber)
 {
   ::DDS::ReturnCode_t const retval = subscriber->delete_datareader (this);
@@ -547,9 +547,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::delete_datareader (
   this->impl_ = 0;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename DDS_TYPE::data_reader *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::impl (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
 {
   if (this->impl_)
     {
@@ -561,19 +561,18 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::impl (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::enable (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
 {
   return this->impl ()->enable ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
 {
   ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
   DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
   if (sc)
     {
@@ -581,49 +580,35 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
                         CCM_DDS_StatusCondition_i (sc),
                         CORBA::NO_MEMORY ());
     }
-#else
-  ::DDS::StatusCondition_var sc = this->impl ()->get_statuscondition ();
-  if (! ::CORBA::is_nil (sc.in ()))
-    {
-      ACE_NEW_THROW_EX (retval,
-                        CCM_DDS_StatusCondition_i (sc.in ()),
-                        CORBA::NO_MEMORY ());
-    }
-#endif
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
 {
   return this->impl ()->get_status_changes ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_INSTANCE_HANDLE_T_RETN
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_InstanceHandle_t const rtihandle =
     this->impl ()->get_instance_handle ();
   ::DDS::InstanceHandle_t handle;
   handle <<= rtihandle;
   return handle;
-#else
-  return this->impl ()->get_instance_handle ();
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReadCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_readcondition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_readcondition (
   ::DDS::SampleStateMask sample_states,
   ::DDS::ViewStateMask view_states,
   ::DDS::InstanceStateMask instance_states)
 {
   ::DDS::ReadCondition_var retval = ::DDS::ReadCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
   DDSReadCondition* rc =
     this->impl ()->create_readcondition (sample_states, view_states, instance_states);
   if (rc)
@@ -632,23 +617,12 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_readcondition (
                         ReadCondition_type (rc),
                         CORBA::NO_MEMORY ());
     }
-#else
-  ::DDS::ReadCondition_var rc =
-    this->impl ()->create_readcondition (sample_states, view_states, instance_states);
-  if (! ::CORBA::is_nil (rc.in ()))
-    {
-      retval = new CCM_DDS_StatusCondition_i<DDS_TYPE, CCM_TYPE> (sc.in ());
-      ACE_NEW_THROW_EX (retval,
-                        ReadCondition_type (sc.in ()),
-                        CORBA::NO_MEMORY ());
-    }
-#endif
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::QueryCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_querycondition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_querycondition (
   ::DDS::SampleStateMask sample_states,
   ::DDS::ViewStateMask view_states,
   ::DDS::InstanceStateMask instance_states,
@@ -656,7 +630,6 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_querycondition (
   const ::DDS::StringSeq & query_parameters)
 {
   ::DDS::QueryCondition_var retval = ::DDS::QueryCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_StringSeq parameters;
   parameters <<= query_parameters;
   DDSQueryCondition* qc = this->impl ()->create_querycondition (
@@ -672,87 +645,59 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::create_querycondition (
                         QueryCondition_type (qc),
                         CORBA::NO_MEMORY ());
     }
-#else
-  ::DDS::QueryCondition_var qc = this->impl ()->create_querycondition (
-                                sample_states,
-                                view_states,
-                                instance_states,
-                                query_expression,
-                                query_parameters);
-
-  if (! ::CORBA::is_nil (qc.in ()))
-    {
-      ACE_NEW_THROW_EX (retval,
-                        QueryCondition_type (qc.in ()),
-                        CORBA::NO_MEMORY ());
-    }
-#endif
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::delete_readcondition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_readcondition (
   ::DDS::ReadCondition_ptr a_condition)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
-  CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE> *rc =
-    dynamic_cast< CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE> *> (a_condition);
+  CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *rc =
+    dynamic_cast< CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *> (a_condition);
   if (!rc)
     {
       return ::DDS::RETCODE_BAD_PARAMETER;
     }
   return this->impl ()->delete_readcondition (rc->get_impl ());
-#else
-  return this->impl ()->delete_readcondition (a_condition);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::delete_contained_entities (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
 {
   return this->impl ()->delete_contained_entities ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_qos (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
   const ::DDS::DataReaderQos &qos)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_DataReaderQos ddsqos;
   ddsqos <<= qos;
   return this->impl ()->set_qos (ddsqos);
-#else
-  return this->impl ()->set_qos (qos);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_qos (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
   ::DDS::DataReaderQos &qos)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_DataReaderQos ddsqos;
   ::DDS_ReturnCode_t const retval = this->impl ()->get_qos (ddsqos);
   qos <<= ddsqos;
   return retval;
-#else
-  return this->impl ()->get_qos (qos);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_listener (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
   ::DDS::DataReaderListener_ptr a_listener,
   ::DDS::StatusMask mask)
 {
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_listener");
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
-#if (CIAO_DDS4CCM_NDDS==1)
   DataReaderListener_type * ccm_dds_drl = 0;
   if (! ::CORBA::is_nil (a_listener))
     {
@@ -764,39 +709,31 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_listener (
     }
   this->lst_mask_ = mask;
   return this->impl ()->set_listener (ccm_dds_drl, mask);
-#else
-  return this->impl ()->set_listener (a_listener, mask);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::DataReaderListener_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
 {
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_listener");
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
-#if (CIAO_DDS4CCM_NDDS==1)
   DDSDataReaderListener *drl = this->impl ()->get_listener ();
-  CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE> *ccm_dds_drl =
-    dynamic_cast <CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE> *> (drl);
+  CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *ccm_dds_drl =
+    dynamic_cast <CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *> (drl);
   if (!ccm_dds_drl)
     {
-      DDS4CCM_DEBUG (6, (LM_DEBUG, "CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_listener - "
+      DDS4CCM_DEBUG (6, (LM_DEBUG, "CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                 "DDS returned a NIL listener.\n"));
       return ::DDS::DataReaderListener::_nil ();
     }
   return ccm_dds_drl->get_datareaderlistener ();
-#else
-  return this->impl ()->get_listener ();
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::TopicDescription_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_topicdescription (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_topicdescription (void)
 {
   ::DDS::TopicDescription_var dds_td = ::DDS::TopicDescription::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDSTopicDescription* td = this->impl ()->get_topicdescription ();
   ::DDSTopic * tp = ::DDSTopic::narrow (td);
   if (tp)
@@ -816,163 +753,116 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_topicdescription (void)
                             CORBA::NO_MEMORY ());
         }
     }
-#else
-  ::DDS::TopicDescription_var td = this->impl ()->get_topicdescription ();
-  ACE_NEW_THROW_EX (dds_td,
-                    CCM_DDS_TopicDescription_T (td.in ()),
-                    CORBA::NO_MEMORY ());
-#endif
   return dds_td._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::Subscriber_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_subscriber (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_subscriber (void)
 {
   ::DDS::Subscriber_var dds_td = ::DDS::Subscriber::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDSSubscriber* subscriber = this->impl ()->get_subscriber ();
   ACE_NEW_THROW_EX (dds_td,
                     Subscriber_type (subscriber),
                     CORBA::NO_MEMORY ());
-#else
-  ::DDSSubscriber_var subscriber = this->impl ()->get_subscriber ();
-  dds_td = new CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE> (subscriber.in ());
-  ACE_NEW_THROW_EX (dds_td,
-                    Subscriber_type (subscriber.in ()),
-                    CORBA::NO_MEMORY ());
-#endif
   return dds_td._retn ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_sample_rejected_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_rejected_status (
   ::DDS::SampleRejectedStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_SampleRejectedStatus ddsstatus;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_sample_rejected_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_sample_rejected_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_liveliness_changed_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_liveliness_changed_status (
   ::DDS::LivelinessChangedStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_LivelinessChangedStatus ddsstatus;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_liveliness_changed_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_liveliness_changed_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_requested_deadline_missed_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_requested_deadline_missed_status (
   ::DDS::RequestedDeadlineMissedStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_RequestedDeadlineMissedStatus ddsstatus;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_requested_deadline_missed_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_requested_deadline_missed_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_requested_incompatible_qos_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_requested_incompatible_qos_status (
   ::DDS::RequestedIncompatibleQosStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_RequestedIncompatibleQosStatus ddsstatus;
   ::DDS::ReturnCode_t const retval =
     this->impl ()->get_requested_incompatible_qos_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_requested_incompatible_qos_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_subscription_matched_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_subscription_matched_status (
   ::DDS::SubscriptionMatchedStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_SubscriptionMatchedStatus ddsstatus;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_subscription_matched_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_subscription_matched_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_sample_lost_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_lost_status (
   ::DDS::SampleLostStatus & status)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   DDS_SampleLostStatus ddsstatus;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_sample_lost_status (ddsstatus);
   status <<= ddsstatus;
   return retval;
-#else
-  return this->impl ()->get_sample_lost_status (status);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::wait_for_historical_data (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::wait_for_historical_data (
   const ::DDS::Duration_t & max_wait)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_Duration_t rtiduration;
   rtiduration <<= max_wait;
   return this->impl ()->wait_for_historical_data (rtiduration);
-#else
-  return this->impl ()->wait_for_historical_data (max_wait);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_matched_publications (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_publications (
   ::DDS::InstanceHandleSeq & publication_handles)
 {
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_matched_publications");
-#if (CIAO_DDS4CCM_NDDS==1)
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_publications");
   ::DDS_InstanceHandleSeq rtiseq;
   ::DDS::ReturnCode_t const retval = this->impl ()->get_matched_publications (rtiseq);
   publication_handles <<= rtiseq;
   return retval;
-#else
-  return this->impl ()->get_matched_publications (publication_handles);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_matched_publication_data (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_publication_data (
   ::DDS::PublicationBuiltinTopicData & publication_data,
   DDS_INSTANCE_HANDLE_T_IN publication_handle)
 {
-#if (CIAO_DDS4CCM_NDDS==1)
   ::DDS_PublicationBuiltinTopicData ccm_dds_pub_data;
   ::DDS_InstanceHandle_t ccm_dds_pub_handle;
 
@@ -983,28 +873,25 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_matched_publication_data (
                                               ccm_dds_pub_handle);
   publication_data <<= ccm_dds_pub_data;
   return retcode;
-#else
-  return this->impl ()->get_matched_publication_data (publication_data, publication_handle);
-#endif
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename DDS_TYPE::data_reader *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
 {
   return this->impl_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::get_mask (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (void)
 {
   return this->lst_mask_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE>::set_impl (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (
   ::DDS::DataReader_ptr dr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::set_impl");
diff --git a/CIAO/connectors/dds4ccm/impl/DataReader_T.h b/CIAO/connectors/dds4ccm/impl/DataReader_T.h
index c3a071f24d8..e6ce232d00d 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReader_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReader_T.h
@@ -25,31 +25,31 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ReadCondition_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_QueryCondition_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataReaderListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T
       : public virtual ::DDS::CCM_DataReader,
         public virtual ::CORBA::LocalObject
     {
-    typedef ::CIAO::DDS4CCM::CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE>
+    typedef ::CIAO::DDS4CCM::CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       DataReaderListener_type;
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
-    typedef CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE> ReadCondition_type;
-    typedef CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE> QueryCondition_type;
-    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE> ContentFilteredTopic_type;
-    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE> Subscriber_type;
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
+    typedef CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ReadCondition_type;
+    typedef CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> QueryCondition_type;
+    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ContentFilteredTopic_type;
+    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Subscriber_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
     public:
       /// Constructor
       DataReader_T (DDSDataReader * dr);
diff --git a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
index 502c7309df9..ae4be0009ff 100644
--- a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
@@ -4,71 +4,71 @@
 #include "dds4ccm/impl/DataWriter_T.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::DataWriterListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DataWriterListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataWriterListener_T::DataWriterListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::~DataWriterListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DataWriterListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataWriterListener_T::~DataWriterListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::OfferedDeadlineMissedStatus &)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos (
   ::DDS::DataWriter_ptr ,
   const ::DDS::OfferedIncompatibleQosStatus &)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost (
   ::DDS::DataWriter_ptr ,
   const ::DDS::LivelinessLostStatus &)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched (
   ::DDS::DataWriter_ptr ,
   const ::DDS::PublicationMatchedStatus &)
 {
 }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache_changed (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::ReliableWriterCacheChangedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activity_changed (
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::ReliableReaderActivityChangedStatus &)
 {
 }
 #endif
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE>::get_mask (void)
+CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataWriterListener_T::get_mask");
   return 0;
diff --git a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.h b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.h
index 3cc655cab16..9b680a8aca4 100644
--- a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.h
@@ -18,7 +18,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataWriterListener_T :
       public ::DDS::DataWriterListener,
       private ACE_Copy_Disabled
diff --git a/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp b/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp
index 28e000a06e3..63dfa9efe12 100644
--- a/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp
@@ -22,45 +22,37 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DataWriter_T (DDSDataWriter * dw)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DataWriter_T (DDSDataWriter * dw)
       : CCM_DDS_DataWriter_Base (dw)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::set_qos (const ::DDS::DataWriterQos & qos)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::DataWriterQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::set_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
       ::DDS_DataWriterQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_qos (ccm_dds_qos);
-#else
-      return this->impl ()->set_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_qos (::DDS::DataWriterQos & qos)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::DataWriterQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
       ::DDS_DataWriterQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       ::DDS::ReturnCode_t retcode = this->impl()->get_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
-#else
-      return this->impl ()->get_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::set_listener (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
       ::DDS::DataWriterListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
@@ -75,174 +67,131 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriterListener_ptr
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDataWriterListener *wr = this->impl ()->get_listener ();
       DataWriterListener_type * list_proxy =
         dynamic_cast <DataWriterListener_type *> (wr);
       if (!list_proxy)
         {
-          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_listener - "
+          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                     "DDS returned a NIL listener.\n"));
           return ::DDS::DataWriterListener::_nil ();
         }
       return list_proxy->get_datawriterlistener ();
-#else
-      return this->impl ()->get_listener ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_topic (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_topic (void)
     {
       ::DDS::Topic_var retval = ::DDS::Topic::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSTopic* t = this->impl ()->get_topic ();
       ACE_NEW_THROW_EX (retval,
                         Topic_type (t),
                         CORBA::NO_MEMORY ());
-#else
-      ::DDS::Topic_var t = this->impl ()->get_topic ();
-      ACE_NEW_THROW_EX (retval,
-                        CCM_DDS_Topic_T (t.in ()),
-                        CORBA::NO_MEMORY ());
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_publisher (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_publisher (void)
     {
       ::DDS::Publisher_var retval = ::DDS::Publisher::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSPublisher* p = this->impl ()->get_publisher ();
       ACE_NEW_THROW_EX (retval,
                         Publisher_type (p),
                         CORBA::NO_MEMORY ());
-#else
-      ::DDS::Publisher_var p = this->impl ()->get_publisher ();
-      ACE_NEW_THROW_EX (retval,
-                        Publisher_type (p.in ()),
-                        CORBA::NO_MEMORY ());
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::wait_for_acknowledgments (const ::DDS::Duration_t & max_wait)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::wait_for_acknowledgments (const ::DDS::Duration_t & max_wait)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
      ::DDS_Duration_t rtiduration;
      rtiduration <<= max_wait;
      return this->impl ()->wait_for_acknowledgments (rtiduration);
-#else
-     return this->impl ()->wait_for_acknowledgments (max_wait);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_liveliness_lost_status (::DDS::LivelinessLostStatus & status)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_liveliness_lost_status (::DDS::LivelinessLostStatus & status)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_LivelinessLostStatus ddsstatus;
       ddsstatus <<= status;
       ::DDS::ReturnCode_t const retval = this->impl ()->get_liveliness_lost_status (ddsstatus);
       status <<= ddsstatus;
       return retval;
-#else
-      return this->impl ()->get_liveliness_lost_status (status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_offered_deadline_missed_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_offered_deadline_missed_status (
       ::DDS::OfferedDeadlineMissedStatus & status)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_OfferedDeadlineMissedStatus ddsstatus;
       ddsstatus <<= status;
       ::DDS::ReturnCode_t const retval =
         this->impl ()->get_offered_deadline_missed_status (ddsstatus);
       status <<= ddsstatus;
       return retval;
-#else
-      return this->impl ()->get_offered_deadline_missed_status (status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_offered_incompatible_qos_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_offered_incompatible_qos_status (
       ::DDS::OfferedIncompatibleQosStatus & status)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_OfferedIncompatibleQosStatus ddsstatus;
       ddsstatus <<= status;
       ::DDS::ReturnCode_t const retval =
         this->impl ()->get_offered_incompatible_qos_status (ddsstatus);
       status <<= ddsstatus;
       return retval;
-#else
-      return this->impl ()->get_offered_incompatible_qos_status (status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_publication_matched_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_publication_matched_status (
       ::DDS::PublicationMatchedStatus & status)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_PublicationMatchedStatus ddsstatus;
       ddsstatus <<= status;
       ::DDS::ReturnCode_t const retval =
         this->impl ()->get_publication_matched_status (ddsstatus);
       status <<= ddsstatus;
       return retval;
-#else
-      return this->impl ()->get_publication_matched_status (status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::assert_liveliness (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::assert_liveliness (void)
     {
       return this->impl ()->assert_liveliness ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_matched_subscriptions (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_subscriptions (
       ::DDS::InstanceHandleSeq & subscription_handles)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandleSeq rtiseq;
       rtiseq <<= subscription_handles;
       ::DDS::ReturnCode_t const retval = this->impl ()->get_matched_subscriptions (rtiseq);
       subscription_handles <<= rtiseq;
       return retval;
-#else
-      return this->impl ()->get_matched_subscriptions (subscription_handles);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_matched_subscription_data (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_subscription_data (
       ::DDS::SubscriptionBuiltinTopicData & subscription_data,
       DDS_INSTANCE_HANDLE_T_IN subscription_handle)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_matched_subscription_data");
-#if (CIAO_DDS4CCM_NDDS==1)
+      DDS4CCM_TRACE ("CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_subscription_data");
       ::DDS_SubscriptionBuiltinTopicData ccm_dds_sub_data;
       ::DDS_InstanceHandle_t ccm_dds_sub_handle;
       ccm_dds_sub_handle <<= subscription_handle;
@@ -250,57 +199,43 @@ namespace CIAO
         this->impl ()->get_matched_subscription_data (ccm_dds_sub_data, ccm_dds_sub_handle);
       subscription_data <<= ccm_dds_sub_data;
       return retval;
-#else
-      return this->impl ()->get_matched_subscription_data (subscription_data, subscription_handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::enable (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       ACE_NEW_THROW_EX (retval,
                         CCM_DDS_StatusCondition_i (sc),
                         CORBA::NO_MEMORY ());
-#else
-      ::DDS::StatusCondition_var sc = this->impl ()->get_statuscondition ();
-      ACE_NEW_THROW_EX (retval,
-                        CCM_DDS_StatusCondition_i (sc.in ()),
-                        CORBA::NO_MEMORY ());
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
     {
       return this->impl ()->get_status_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDS_INSTANCE_HANDLE_T_RETN
-    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t const rtihandle =
         this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
       handle <<= rtihandle;
       return handle;
-#else
-      return this->impl ()->get_instance_handle ();
-#endif
     }
   }
 }
diff --git a/CIAO/connectors/dds4ccm/impl/DataWriter_T.h b/CIAO/connectors/dds4ccm/impl/DataWriter_T.h
index 0832cee89d3..26872beac5c 100644
--- a/CIAO/connectors/dds4ccm/impl/DataWriter_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter_T.h
@@ -31,22 +31,22 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Publisher_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriter_T
       : public virtual CCM_DDS_DataWriter_Base
     {
-    typedef CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE> DataWriterListener_type;
-    typedef CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE> Publisher_type;
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
+    typedef CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriterListener_type;
+    typedef CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Publisher_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
 
     public:
       explicit CCM_DDS_DataWriter_T (DDSDataWriter * dw);
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp
index 5dd89a448ad..2db8eca686b 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp
@@ -26,31 +26,31 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DomainParticipantFactory_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipantFactory_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DomainParticipantFactory_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipantFactory_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DomainParticipantFactory_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipantFactory_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DomainParticipantFactory_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipantFactory_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::create_participant (::DDS::DomainId_t domain_id,
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant (::DDS::DomainId_t domain_id,
                                                         const ::DDS::DomainParticipantQos & qos,
                                                         ::DDS::DomainParticipantListener_ptr a_listener,
                                                         ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::create_participant");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (qos);
 
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::create_participant - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant - "
                    "Creating domain participant for domain <%d>\n",
                    domain_id));
 
@@ -78,7 +78,7 @@ namespace CIAO
           if (!dds_dp)
             {
               DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                          "<DDS_TYPE, CCM_TYPE>::create_participant - "
+                          "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant - "
                           "Error: Unable to create DomainParticipant for domain <%d>\n",
                           domain_id));
               throw CCM_DDS::InternalError (1, 0);
@@ -103,7 +103,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                      "<DDS_TYPE, CCM_TYPE>::create_participant - "
+                      "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant - "
                       "Re-using participant for QOS profile <%C> and domain <%d>.\n",
                       qos_profile.c_str (),
                       domain_id));
@@ -123,20 +123,20 @@ namespace CIAO
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::create_participant_with_profile (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant_with_profile (
       ::DDS::DomainId_t domain_id,
       const char * library_name,
       const char * profile_name,
       ::DDS::DomainParticipantListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
                      "create_participant_with_profile");
 
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                    "<DDS_TYPE, CCM_TYPE>::create_participant_with_profile - "
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant_with_profile - "
                     "Creating domain participant: profile <%C#%C> - domain <%d>\n",
                     library_name, profile_name, domain_id));
       CCM_DDS_DomainParticipantListener_i *ccm_dds_dpl = 0;
@@ -158,7 +158,7 @@ namespace CIAO
       if (!dds_dp)
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_participant_with_profile - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant_with_profile - "
                         "Creating participant: profile <%C> - domain <%d>\n",
                         qos_profile.c_str (),
                         domain_id));
@@ -171,7 +171,7 @@ namespace CIAO
           if (!dds_dp)
             {
               DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                            "<DDS_TYPE, CCM_TYPE>::create_participant_with_profile - "
+                            "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant_with_profile - "
                             "Error: Unable to create DomainParticipant\n"));
               throw CCM_DDS::InternalError (1, 0);
             }
@@ -193,7 +193,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                      "<DDS_TYPE, CCM_TYPE>::create_participant_with_profile - "
+                      "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant_with_profile - "
                       "Re-using participant for QOS profile <%C> and domain <%d>.\n",
                       qos_profile.c_str (),
                       domain_id));
@@ -207,12 +207,12 @@ namespace CIAO
 #endif
 
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::delete_participant (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant (
       ::DDS::DomainParticipant_ptr a_participant)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::delete_participant");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       DomainParticipant_type *part =
@@ -221,12 +221,12 @@ namespace CIAO
       if (!part)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_participant - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                         "Unable to cast provided object reference to servant type, bailing.\n"));
           return DDS::RETCODE_ERROR;
         }
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                    "<DDS_TYPE, CCM_TYPE>::delete_participant - "
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                     "Successfully casted provided object reference to servant type.\n"));
 
       ::DDS::ReturnCode_t retval = DDS::RETCODE_OK;
@@ -238,12 +238,12 @@ namespace CIAO
           if (retval != DDS::RETCODE_OK)
             {
               DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                            "<DDS_TYPE, CCM_TYPE>::delete_participant - "
+                            "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                             "RTI delete_participant returned non-ok error code %C\n",
                             translate_retcode (retval)));
             }
           else DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipantFactory_T"
-                            "<DDS_TYPE, CCM_TYPE>::delete_participant - "
+                            "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                             "Successfully deleted provided participant.\n"));
         }
       return retval;
@@ -253,9 +253,9 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::lookup_participant (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_participant (
       ::DDS::DomainId_t domain_id)
     {
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
@@ -275,12 +275,12 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::set_default_participant_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_participant_qos (
       const ::DDS::DomainParticipantQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
         "set_default_participant_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       DDS_DomainParticipantQos ccm_dds_qos;
@@ -293,12 +293,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::get_default_participant_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_participant_qos (
       ::DDS::DomainParticipantQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
         "get_default_participant_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       DDS_DomainParticipantQos ccm_dds_qos;
@@ -313,12 +313,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::set_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
       const ::DDS::DomainParticipantFactoryQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       DDS_DomainParticipantFactoryQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -328,12 +328,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::get_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
       ::DDS::DomainParticipantFactoryQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::get_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       DDS_DomainParticipantFactoryQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
@@ -346,13 +346,13 @@ namespace CIAO
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::set_default_participant_qos_with_profile (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_participant_qos_with_profile (
                                                         const char * library_name,
                                                         const char * profile_name)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
                      "set_default_participant_qos_with_profile");
 
       return DDSDomainParticipantFactory::get_instance ()->
@@ -361,15 +361,15 @@ namespace CIAO
 #endif
 
 #if (CIAO_DDS4CCM_OPENDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipantFactory_ptr
-    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>::get_instance (void)
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance (void)
     {
       ::DDS::DomainParticipantFactory_var retval =
         ::DDS::DomainParticipantFactory::_nil ();
 
       ACE_NEW_THROW_EX (retval,
-        CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE>,
+        CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>,
         CORBA::NO_MEMORY ());
 
       return retval._retn ();
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h
index 053db5569d7..2393aba1b03 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h
@@ -24,18 +24,18 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipantFactory_T :
       public virtual ::DDS::CCM_DomainParticipantFactory,
       public virtual ::CORBA::LocalObject
     {
 
     public:
-      typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
-      typedef CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE> DomainParticipantFactory_type;
+      typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
+      typedef CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipantFactory_type;
       friend class ACE_Singleton<DomainParticipantFactory_type, TAO_SYNCH_MUTEX>;
 
       // Construtor
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.cpp
index e5be9e17a77..e1d3f8024fa 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.cpp
@@ -7,143 +7,143 @@
 
 #include "tao/ORB_Core.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::DomainParticipantListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::DomainParticipantListener_T (
       ::CCM_DDS::ConnectorStatusListener_ptr error_listener)
       : error_listener_ (::CCM_DDS::ConnectorStatusListener::_duplicate (error_listener))
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DomainParticipantListener_T::DomainParticipantListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::~DomainParticipantListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~DomainParticipantListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DomainParticipantListener_T::~DomainParticipantListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_inconsistent_topic (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_inconsistent_topic (
   ::DDS::Topic_ptr,
   const ::DDS::InconsistentTopicStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed (
   ::DDS::DataReader_ptr ,
   const ::DDS::RequestedDeadlineMissedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos (
   ::DDS::DataReader_ptr ,
   const ::DDS::RequestedIncompatibleQosStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected (
   ::DDS::DataReader_ptr ,
   const ::DDS::SampleRejectedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed (
   ::DDS::DataReader_ptr ,
   const ::DDS::LivelinessChangedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available (
   ::DDS::DataReader_ptr )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched (
   ::DDS::DataReader_ptr ,
   const ::DDS::SubscriptionMatchedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost (
   ::DDS::DataReader_ptr ,
   const ::DDS::SampleLostStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::OfferedDeadlineMissedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos (
   ::DDS::DataWriter_ptr ,
   const ::DDS::OfferedIncompatibleQosStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost (
   ::DDS::DataWriter_ptr ,
   const ::DDS::LivelinessLostStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched (
   ::DDS::DataWriter_ptr ,
   const ::DDS::PublicationMatchedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_data_on_readers (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_on_readers (
   ::DDS::Subscriber_ptr )
 {
 }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache_changed (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::ReliableWriterCacheChangedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activity_changed (
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed (
   ::DDS::DataWriter_ptr ,
   const ::DDS::ReliableReaderActivityChangedStatus & )
 {
 }
 #endif
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE>::get_mask (void)
+CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DomainParticipantListener_T::get_mask");
   return 0;
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.h b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.h
index 2772ac4a79f..7d457c51480 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener_T.h
@@ -22,7 +22,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DomainParticipantListener_T :
       public virtual ::DDS::CCM_DomainParticipantListener,
       public virtual ::CORBA::LocalObject,
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp
index b3cdf4ed946..da9822a2033 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp
@@ -34,23 +34,23 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DomainParticipant_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipant_T (
       DDSDomainParticipant * dp) : impl_ (dp)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_DomainParticipant_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipant_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DomainParticipant_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipant_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_DomainParticipant_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipant_T");
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher_with_profile (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher_with_profile (
       const char* library_name,
       const char *profile_name,
       ::DDS::PublisherListener_ptr a_listener,
@@ -58,9 +58,9 @@ namespace CIAO
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_publisher_with_profile");
 
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher_with_profile - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher_with_profile - "
                    "Creating Publisher\n"));
-      CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE> *ccm_dds_pl = 0;
+      CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *ccm_dds_pl = 0;
       if (! ::CORBA::is_nil (a_listener))
         {
           ACE_NEW_THROW_EX (ccm_dds_pl,
@@ -75,7 +75,7 @@ namespace CIAO
 
       if (!ccm_dds_pub)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher_with_profile - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher_with_profile - "
                        "Error: Unable to create Publisher\n"));
           delete ccm_dds_pl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -87,7 +87,7 @@ namespace CIAO
                         CORBA::NO_MEMORY ());
 
 
-      DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher_with_profile - "
+      DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher_with_profile - "
                    "Successfully created a DDSPublisher\n"));
 
       ccm_dds_pub->enable ();
@@ -95,22 +95,21 @@ namespace CIAO
     }
 #endif
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher (
       const ::DDS::PublisherQos & qos,
       ::DDS::PublisherListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_publisher");
-#if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (qos);
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_publisher - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher - "
                    "Creating Publisher\n"));
 
       DDS_PublisherQos ccm_dds_qos = DDS_PUBLISHER_QOS_DEFAULT;
 
-      CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE> *ccm_dds_pl = 0;
+      CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *ccm_dds_pl = 0;
       if (! ::CORBA::is_nil (a_listener))
         {
           ACE_NEW_THROW_EX (ccm_dds_pl,
@@ -126,7 +125,7 @@ namespace CIAO
       if (!ccm_dds_pub)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T"
-                       "<DDS_TYPE, CCM_TYPE>::create_publisher - "
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher - "
                        "Error: Unable to create Publisher\n"));
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
         }
@@ -137,19 +136,16 @@ namespace CIAO
                         CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T"
-                   "<DDS_TYPE, CCM_TYPE>::create_publisher - "
+                   "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher - "
                    "Successfully created a DDSPublisher\n"));
 
       ccm_dds_pub->enable ();
       return retval._retn ();
-#else
-      return this->impl ()->create_publisher (qos, a_listener, mask);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_publisher (::DDS::Publisher_ptr p)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher (::DDS::Publisher_ptr p)
     {
       Publisher_type *ccm_dds_pub =
         dynamic_cast < Publisher_type * > (p);
@@ -157,13 +153,13 @@ namespace CIAO
       if (!ccm_dds_pub)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T"
-                       "<DDS_TYPE, CCM_TYPE>::delete_publisher - "
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                        "Unable to cast provided object reference to servant pointer.\n"));
           return ::DDS::RETCODE_ERROR;
         }
 
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T"
-                   "<DDS_TYPE, CCM_TYPE>::delete_publisher - "
+                   "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                    "Successfully casted provided object reference to "
                    "CCM_DDS_Publisher_T\n"));
 
@@ -172,14 +168,14 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T"
-                       "<DDS_TYPE, CCM_TYPE>::delete_publisher - "
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                        "Error: RTI delete_publisher returned non-ok error code %C\n",
                        translate_retcode (retval)));
         }
       else
         {
           DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_publisher - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                         "Provided publisher successfully deleted\n"));
         }
 
@@ -187,9 +183,9 @@ namespace CIAO
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_subscriber_with_profile (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber_with_profile (
       const char* library_name,
       const char *profile_name,
       ::DDS::SubscriberListener_ptr a_listener,
@@ -198,7 +194,7 @@ namespace CIAO
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_subscriber_with_profile");
 
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T"
-                   "<DDS_TYPE, CCM_TYPE>::create_subscriber_with_profile - "
+                   "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber_with_profile - "
                    "Creating Subscriber\n"));
 
       SubscriberListener_type *ccm_dds_sl = 0;
@@ -218,7 +214,7 @@ namespace CIAO
       if (!ccm_dds_sub)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_subscriber_with_profile - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber_with_profile - "
                        "Error: Unable to create Subscriber\n"));
           delete ccm_dds_sl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -230,7 +226,7 @@ namespace CIAO
                         CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T"
-                    "<DDS_TYPE, CCM_TYPE>::create_subscriber_with_profile - "
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber_with_profile - "
                     "Successfully created a DDSSubscriber\n"));
 
       ccm_dds_sub->enable ();
@@ -238,18 +234,17 @@ namespace CIAO
     }
 #endif
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_subscriber (const ::DDS::SubscriberQos & qos,
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber (const ::DDS::SubscriberQos & qos,
                                                 ::DDS::SubscriberListener_ptr a_listener,
                                                 ::DDS::StatusMask mask)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_subscriber");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (qos);
 
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_subscriber - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber - "
                    "Creating Subscriber\n"));
 
       SubscriberListener_type *ccm_dds_sl = 0;
@@ -268,7 +263,7 @@ namespace CIAO
 
       if (!ccm_dds_sub)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_subscriber - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber - "
                        "Error: Unable to create Subscriber\n"));
           delete ccm_dds_sl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -279,59 +274,51 @@ namespace CIAO
                         Subscriber_type (ccm_dds_sub),
                         CORBA::NO_MEMORY ());
 
-      DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_subscriber - "
+      DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber - "
                    "Successfully created a DDSSubscriber\n"));
 
       ccm_dds_sub->enable ();
       return retval._retn ();
-#else
-      return this->impl ()->create_subscriber (qos, a_listener, mask);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_subscriber (::DDS::Subscriber_ptr s)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber (::DDS::Subscriber_ptr s)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       Subscriber_type *ccm_dds_sub = dynamic_cast < Subscriber_type * > (s);
 
       if (!ccm_dds_sub)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_subscriber - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber - "
                        "Unable to cast provided object reference to servant pointer.\n"));
           return ::DDS::RETCODE_ERROR;
         }
 
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_subscriber - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber - "
                    "Successfully casted provided object reference to Subscriber_type\n"));
 
       DDS_ReturnCode_t const retval = this->impl ()->delete_subscriber (ccm_dds_sub->get_impl ());
 
       if (retval != DDS_RETCODE_OK)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_subscriber - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber - "
                        "Error: RTI delete_subscriber returned non-ok error code %C\n",
                        translate_retcode (retval)));
         }
       else
         {
-          DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_subscriber - "
+          DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber - "
                         "Provided subscriber successfully deleted\n"));
         }
 
       return retval;
-#else
-      return this->impl ()->delete_subscriber (s);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_builtin_subscriber (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_builtin_subscriber (void)
     {
       ::DDS::Subscriber_var retval = ::DDS::Subscriber::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSSubscriber* sub = this->impl ()->get_builtin_subscriber ();
       if (sub)
         {
@@ -339,21 +326,12 @@ namespace CIAO
                             Subscriber_type (sub),
                             CORBA::NO_MEMORY ());
         }
-#else
-      ::DDS::Subscriber_var sub = this->impl ()->get_builtin_subscriber ();
-      if (! ::CORBA::is_nil (sub.in ()))
-        {
-          ACE_NEW_THROW_EX (retval,
-                            Subscriber_type (sub.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_topic (const char * impl_name,
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_topic (const char * impl_name,
                                            const char * type_name,
                                            const ::DDS::TopicQos & qos,
                                            ::DDS::TopicListener_ptr a_listener,
@@ -361,7 +339,6 @@ namespace CIAO
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_topic");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (qos);
 
       if (impl_name == 0)
@@ -446,19 +423,12 @@ namespace CIAO
 
           return retval._retn ();
         }
-#else
-      return this->impl ()->create_topic (impl_name,
-                                                      type_name,
-                                                      qos,
-                                                      a_listener,
-                                                      mask);
-#endif
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_topic_with_profile (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_topic_with_profile (
         const char *impl_name,
         const char *type_name,
         const char *library_name,
@@ -552,9 +522,9 @@ namespace CIAO
     }
 #endif
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_topic (::DDS::Topic_ptr a_topic)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_topic (::DDS::Topic_ptr a_topic)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::delete_topic");
       const char * topic_name = a_topic->get_name ();
@@ -564,13 +534,13 @@ namespace CIAO
 
       if (!tp)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_topic <%C> - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_topic <%C> - "
                        "Unable to cast provided object reference to servant.\n",
                        topic_name));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
 
-      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_topic <%C> - "
+      DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_topic <%C> - "
                    "Successfully casted provided object reference to servant.\n",
                    topic_name));
 
@@ -581,14 +551,14 @@ namespace CIAO
 
           if (retval != DDS_RETCODE_OK)
             {
-              DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_topic <%C> - "
+              DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_topic <%C> - "
                           "Error: RTI delete_topic returned non-ok error code %C\n",
                           topic_name,
                           translate_retcode (retval)));
             }
           else
             {
-              DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_topic <%C> - "
+              DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_topic <%C> - "
                             "Provided topic successfully deleted\n",
                             topic_name));
             }
@@ -596,13 +566,12 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::find_topic (const char * impl_name,
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::find_topic (const char * impl_name,
                                          const ::DDS::Duration_t & timeout)
     {
       ::DDS::Topic_var retval = ::DDS::Topic::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_Duration_t ddstimeout;
       ddstimeout <<= timeout;
       ::DDSTopic* topic = this->impl ()->find_topic (impl_name, ddstimeout);
@@ -612,29 +581,19 @@ namespace CIAO
                           Topic_type (topic),
                           ::DDS::Topic::_nil ());
         }
-#else
-      ::DDS::Topic_var topic = this->impl ()->find_topic (impl_name, timeout);
-      if (! ::CORBA::is_nil (topic.in ())
-        {
-          ACE_NEW_RETURN (retval,
-                          ‘Topic_type (topic.in ()),
-                          ::DDS::Topic::_nil ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicDescription_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::lookup_topicdescription (const char * name)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_topicdescription (const char * name)
     {
-      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::lookup_topicdescription");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_topicdescription");
 
       DDS4CCM_DEBUG (7, (LM_DEBUG, CLINFO "Looking up topic: name <%C>\n",
                                    name));
 
       ::DDS::TopicDescription_var retval = ::DDS::TopicDescription::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDSTopicDescription* topic = this->impl ()->lookup_topicdescription (name);
       if (topic)
         {
@@ -658,21 +617,12 @@ namespace CIAO
                 }
             }
         }
-#else
-      ::DDSTopicDescription_var topic = this->impl ()->lookup_topicdescription (name);
-      if (!CORBA::is_ni (topic.in ()))
-        {
-          ACE_NEW_THROW_EX (retval,
-                            CCM_DDS_TopicDescription_T (topic.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ContentFilteredTopic_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_contentfilteredtopic (const char * name,
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_contentfilteredtopic (const char * name,
                                                           ::DDS::Topic_ptr related_topic,
                                                           const char * filter_expression,
                                                           const ::DDS::StringSeq & expression_parameters)
@@ -683,7 +633,7 @@ namespace CIAO
       Topic_type *top = dynamic_cast< Topic_type *> (related_topic);
       if (!top)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_contentfilteredtopic - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_contentfilteredtopic - "
                        "Unable to cast provided topic.\n"));
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
         }
@@ -708,7 +658,7 @@ namespace CIAO
       delete [] parameterlist;
       if (!ccm_dds_cft)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_contentfilteredtopic - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_contentfilteredtopic - "
                        "RTI DDS returned a nil ContentFilteredTopic for name <%C> and filter "
                        "expression <%C>.\n",
                        name, filter_expression));
@@ -735,29 +685,25 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_contentfilteredtopic (::DDS::ContentFilteredTopic_ptr a_contentfilteredtopic)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contentfilteredtopic (::DDS::ContentFilteredTopic_ptr a_contentfilteredtopic)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::delete_contentfilteredtopic");
-#if (CIAO_DDS4CCM_NDDS==1)
       ContentFilteredTopic_type *ccm_dds_cft =
           dynamic_cast < ContentFilteredTopic_type *> (a_contentfilteredtopic);
       if (!ccm_dds_cft)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_contentfilteredtopic - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contentfilteredtopic - "
                        "Unable to cast provided ContentFilteredTopic.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
       return this->impl ()->delete_contentfilteredtopic (ccm_dds_cft->get_impl ());
-#else
-      return this->impl ()->delete_contentfilteredtopic (a_contentfilteredtopic);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::MultiTopic_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::create_multitopic (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_multitopic (
       const char * name,
       const char * type_name,
       const char * subscription_expression,
@@ -779,9 +725,9 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_multitopic (::DDS::MultiTopic_ptr a_multitopic)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_multitopic (::DDS::MultiTopic_ptr a_multitopic)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::delete_multitopic");
 #if (CIAO_DDS4CCM_NDDS==1)
@@ -793,17 +739,17 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::delete_contained_entities (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
     {
       return this->impl ()->delete_contained_entities ();
 
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_qos (const ::DDS::DomainParticipantQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::DomainParticipantQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::set_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
@@ -815,28 +761,23 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_qos (::DDS::DomainParticipantQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::DomainParticipantQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DomainParticipantQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl()-> get_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
-#else
-      return this->impl()->get_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_listener (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
                 ::DDS::DomainParticipantListener_ptr a_listener,
                 ::DDS::StatusMask mask)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       CCM_DDS_DomainParticipantListener_i * ccm_dds_impl_list = 0;
       if (! ::CORBA::is_nil (a_listener))
         {
@@ -845,210 +786,158 @@ namespace CIAO
                             CORBA::NO_MEMORY ());
         }
       return this->impl_->set_listener (ccm_dds_impl_list, mask);
-#else
-      return this->impl_->set_listener (a_listener, mask);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipantListener_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_listener");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDomainParticipantListener *ccm_dds_dp_list = this->impl ()->get_listener ();
       CCM_DDS_DomainParticipantListener_i * list_proxy =
         dynamic_cast <CCM_DDS_DomainParticipantListener_i *> (ccm_dds_dp_list);
       if (!list_proxy)
         {
-          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_listener - "
+          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                     "DDS returned a NIL listener.\n"));
           return ::DDS::DomainParticipantListener::_nil ();
         }
       return list_proxy->get_domainparticipantlistener ();
-#else
-      return this->impl ()->get_listener ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::ignore_participant (DDS_INSTANCE_HANDLE_T_IN handle)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_participant (DDS_INSTANCE_HANDLE_T_IN handle)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t ccm_dds_handle;
       ccm_dds_handle <<= handle;
       return this->impl ()->ignore_participant (ccm_dds_handle);
-#else
-      return this->impl ()->ignore_participant (handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::ignore_topic (DDS_INSTANCE_HANDLE_T_IN handle)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_topic (DDS_INSTANCE_HANDLE_T_IN handle)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t ccm_dds_handle;
       ccm_dds_handle <<= handle;
       return this->impl ()->ignore_topic (ccm_dds_handle);
-#else
-      return this->impl ()->ignore_topic (handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::ignore_publication (DDS_INSTANCE_HANDLE_T_IN handle)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_publication (DDS_INSTANCE_HANDLE_T_IN handle)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t ccm_dds_handle;
       ccm_dds_handle <<= handle;
       return this->impl ()->ignore_publication (ccm_dds_handle);
-#else
-      return this->impl ()->ignore_publication (handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::ignore_subscription (DDS_INSTANCE_HANDLE_T_IN handle)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_subscription (DDS_INSTANCE_HANDLE_T_IN handle)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t ccm_dds_handle;
       ccm_dds_handle <<= handle;
       return this->impl ()->ignore_subscription (ccm_dds_handle);
-#else
-      return this->impl ()->ignore_subscription (handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainId_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_domain_id (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_domain_id (void)
     {
       return this->impl ()->get_domain_id ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::assert_liveliness (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::assert_liveliness (void)
     {
       return this->impl ()->assert_liveliness ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_default_publisher_qos (const ::DDS::PublisherQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_publisher_qos (const ::DDS::PublisherQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::set_default_publisher_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_publisher_qos (ccm_dds_qos);
-#else
-      return this->impl()->set_default_publisher_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_default_publisher_qos (::DDS::PublisherQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_publisher_qos (::DDS::PublisherQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_default_publisher_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_PublisherQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl()-> get_default_publisher_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
-#else
-      return this->impl()->get_default_publisher_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_default_subscriber_qos (const ::DDS::SubscriberQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_subscriber_qos (const ::DDS::SubscriberQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::set_default_subscriber_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_SubscriberQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_subscriber_qos (ccm_dds_qos);
-#else
-      return this->impl()->set_default_subscriber_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_default_subscriber_qos (::DDS::SubscriberQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_subscriber_qos (::DDS::SubscriberQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_default_subscriber_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_SubscriberQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
             this->impl()-> get_default_subscriber_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
-#else
-      return this->impl()->get_default_subscriber_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_default_topic_qos (const ::DDS::TopicQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_topic_qos (const ::DDS::TopicQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::set_default_topic_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_TopicQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_topic_qos (ccm_dds_qos);
-#else
-      return this->impl()->set_default_topic_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_default_topic_qos (::DDS::TopicQos & qos)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_topic_qos (::DDS::TopicQos & qos)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_default_topic_qos");
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_TopicQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
             this->impl()-> get_default_topic_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
-#else
-      return this->impl()->get_default_topic_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_discovered_participants (::DDS::InstanceHandleSeq & impl_handles)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_discovered_participants (::DDS::InstanceHandleSeq & impl_handles)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandleSeq rtiseq;
       ::DDS::ReturnCode_t const retval = this->impl ()->get_discovered_participants (rtiseq);
       impl_handles <<= rtiseq;
       return retval;
-#else
-      return this->impl ()->get_discovered_participants (impl_handles);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_discovered_participant_data (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_discovered_participant_data (
       ::DDS::ParticipantBuiltinTopicData & impl_data,
       DDS_INSTANCE_HANDLE_T_IN impl_handle)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_discovered_participant_data");
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_ParticipantBuiltinTopicData dds_part_data;
       dds_part_data <<= impl_data;
       ::DDS_InstanceHandle_t dds_hnd;
@@ -1058,15 +947,11 @@ namespace CIAO
                                                         dds_hnd);
       impl_data <<= dds_part_data;
       return retcode;
-#else
-      return this->impl ()->get_discovered_topic_data (impl_data,
-                                                       impl_handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_discovered_topics (::DDS::InstanceHandleSeq & impl_handles)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_discovered_topics (::DDS::InstanceHandleSeq & impl_handles)
     {
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandleSeq rtiseq;
@@ -1078,14 +963,13 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_discovered_topic_data (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_discovered_topic_data (
       ::DDS::TopicBuiltinTopicData & impl_data,
       DDS_INSTANCE_HANDLE_T_IN impl_handle)
     {
       DDS4CCM_TRACE ("DDS_DomainParticipant_i::get_discovered_topic_data");
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_TopicBuiltinTopicData dds_tp_data;
       dds_tp_data <<= impl_data;
       ::DDS_InstanceHandle_t dds_hnd;
@@ -1095,52 +979,39 @@ namespace CIAO
                                                   dds_hnd);
       impl_data <<= dds_tp_data;
       return retcode;
-#else
-      return this->impl ()->get_discovered_topic_data (impl_data,
-                                                       impl_handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::CORBA::Boolean
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::contains_entity (DDS_INSTANCE_HANDLE_T_IN a_handle)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::contains_entity (DDS_INSTANCE_HANDLE_T_IN a_handle)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t ccm_dds_handle;
       ccm_dds_handle <<= a_handle;
       return this->impl ()->contains_entity (ccm_dds_handle);
-#else
-      return this->impl ()->contains_entity (a_handle);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_current_time (::DDS::Time_t & current_time)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_current_time (::DDS::Time_t & current_time)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_Time_t ccm_dds_time;
       ::DDS::ReturnCode_t const retval = this->impl ()->get_current_time (ccm_dds_time);
       current_time <<= ccm_dds_time;
       return retval;
-#else
-      return this->impl ()->get_current_time (current_time);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::enable (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       if (sc)
         {
@@ -1148,56 +1019,43 @@ namespace CIAO
                             CCM_DDS_StatusCondition_i (sc),
                             CORBA::NO_MEMORY ());
         }
-#else
-      ::DDS::StatusCondition_var sc = this->impl ()->get_statuscondition ();
-      if (! ::CORBA::is_nil (sc.in ()))
-        {
-          ACE_NEW_THROW_EX (retval,
-                            CCM_DDS_StatusCondition_i (sc.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
     {
       return this->impl ()->get_status_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDS_INSTANCE_HANDLE_T_RETN
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
       handle <<= rtihandle;
       return handle;
-#else
-      return this->impl ()->get_instance_handle ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDomainParticipant *
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSDomainParticipant * dp)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSDomainParticipant * dp)
     {
       this->impl_ = dp;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDomainParticipant *
-    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h
index 8eded919238..f0e6f59f3e7 100644
--- a/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h
@@ -31,43 +31,43 @@ namespace CIAO
   namespace DDS4CCM
   {
     //Forward declarations
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Publisher_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Subscriber_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_TopicListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T;
 
     //Class declaration
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant_T :
       public virtual ::DDS::CCM_DomainParticipant,
       public virtual ::CORBA::LocalObject
     {
-    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE> Subscriber_type;
-    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE> SubscriberListener_type;
-    typedef CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE> Publisher_type;
-    typedef CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE> PublisherListener_type;
-    typedef CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE> TopicListener_type;
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
-    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE> ContentFilteredTopic_type;
+    typedef CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Subscriber_type;
+    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> SubscriberListener_type;
+    typedef CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Publisher_type;
+    typedef CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> PublisherListener_type;
+    typedef CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> TopicListener_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
+    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ContentFilteredTopic_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/Getter_T.cpp b/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
index b7378196fff..215d818b633 100644
--- a/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
@@ -6,8 +6,8 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::Getter_Base_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::Getter_Base_T (void)
   : reader_ (0),
     time_out_ (),
     max_delivered_data_ (0)
@@ -15,15 +15,15 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::Getter_Base_T (void)
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Getter_Base_T::Getter_Base_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::~Getter_Base_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~Getter_Base_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Getter_Base_T::~Getter_Base_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> *
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::impl (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
 {
   if (this->reader_)
     {
@@ -35,24 +35,24 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::impl (void)
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CORBA::Object_ptr
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::_get_component (void)
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_get_component (void)
 {
   return CCM_TYPE::base_type::_duplicate (this->component_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::_set_component (
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_set_component (
   typename CCM_TYPE::base_type::_ptr_type component)
 {
   this->component_ = CCM_TYPE::base_type::_duplicate (component);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::get_many (
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_many (
   typename CCM_TYPE::seq_type& instances,
   ::CCM_DDS::ReadInfoSeq& infos)
 {
@@ -144,9 +144,9 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::get_many (
   return true;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::Duration_t
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::time_out (void)
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::time_out (void)
 {
   ::DDS::Duration_t timeout;
   timeout <<= this->time_out_;
@@ -154,33 +154,33 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::time_out (void)
   return timeout;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::time_out (
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::time_out (
   const ::DDS::Duration_t & time_out)
 {
   this->time_out_ <<= time_out;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::DataNumber_t
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::max_delivered_data (void)
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::max_delivered_data (void)
 {
   return this->max_delivered_data_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::max_delivered_data (
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::max_delivered_data (
   ::CCM_DDS::DataNumber_t max_delivered_data)
 {
   this->max_delivered_data_ = max_delivered_data;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::set_impl (
-  DataReader_T<DDS_TYPE, CCM_TYPE> * dr)
+CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (
+  DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * dr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Getter_Base_T::set_impl");
 
@@ -189,9 +189,9 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE>::set_impl (
 }
 
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, true>::get_one (
+CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, true, VENDOR_TYPE>::get_one (
   typename DDS_TYPE::value_type::_out_type an_instance,
   ::CCM_DDS::ReadInfo_out info)
 {
@@ -269,9 +269,9 @@ CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, true>::get_one (
   return true;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, false>::get_one (
+CIAO::DDS4CCM::DDS_CCM::Getter_T<DDS_TYPE, CCM_TYPE, false, VENDOR_TYPE>::get_one (
   typename DDS_TYPE::value_type::_out_type an_instance,
   ::CCM_DDS::ReadInfo_out info)
 {
diff --git a/CIAO/connectors/dds4ccm/impl/Getter_T.h b/CIAO/connectors/dds4ccm/impl/Getter_T.h
index 92683b5f990..0f1436d9b4a 100644
--- a/CIAO/connectors/dds4ccm/impl/Getter_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Getter_T.h
@@ -40,7 +40,7 @@ namespace CIAO
       *               All methods return a boolean as result indicating whether actual data
       *               are provided (TRUE) or if the time-out occurred (FALSE).
       */
-      template <typename DDS_TYPE, typename CCM_TYPE>
+      template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
       class Getter_Base_T :
          public virtual CCM_TYPE::getter_type,
          public virtual ::CORBA::LocalObject,
@@ -86,32 +86,32 @@ namespace CIAO
         /**
          * Set the actual pointer to DDS Datareader
          */
-        void set_impl (DataReader_T<DDS_TYPE, CCM_TYPE> * reader);
+        void set_impl (DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * reader);
 
         void _set_component (typename CCM_TYPE::base_type::_ptr_type component);
         virtual ::CORBA::Object_ptr _get_component (void);
 
       protected:
-        DataReader_T<DDS_TYPE, CCM_TYPE> * reader_;
+        DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * reader_;
 
         ::DDS_Duration_t time_out_;
         ::CCM_DDS::DataNumber_t max_delivered_data_;
 
-        DataReader_T<DDS_TYPE, CCM_TYPE> * impl (void);
+        DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * impl (void);
       private:
         typename CCM_TYPE::base_type::_var_type component_;
       };
 
-      template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+      template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
       class Getter_T;
 
       /**
       * @brief Implementation of the Getter port for variable sized data types.
       *
       */
-      template <typename DDS_TYPE, typename CCM_TYPE>
-      class Getter_T <DDS_TYPE, CCM_TYPE, false> :
-        public Getter_Base_T <DDS_TYPE, CCM_TYPE>
+      template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+      class Getter_T <DDS_TYPE, CCM_TYPE, false, VENDOR_TYPE> :
+        public Getter_Base_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       {
       public:
         /**
@@ -129,9 +129,9 @@ namespace CIAO
       * @brief Implementation of the Getter port for fixed sized data types.
       *
       */
-      template <typename DDS_TYPE, typename CCM_TYPE>
-      class Getter_T <DDS_TYPE, CCM_TYPE, true> :
-        public Getter_Base_T <DDS_TYPE, CCM_TYPE>
+      template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+      class Getter_T <DDS_TYPE, CCM_TYPE, true, VENDOR_TYPE> :
+        public Getter_Base_T <DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       {
       public:
         /**
diff --git a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
index f33c8d7bd66..86ce30fc29a 100644
--- a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
@@ -5,20 +5,20 @@
 #include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::InstanceHandleManager_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::InstanceHandleManager_T (void)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::~InstanceHandleManager_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::~InstanceHandleManager_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::InstanceHandleManager_T::~InstanceHandleManager_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename DDS_TYPE::data_writer *
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::impl (void)
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::impl (void)
 {
   if (this->writer_)
     {
@@ -30,9 +30,9 @@ CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::impl (voi
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::InstanceHandle_t
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::
   register_instance (const typename DDS_TYPE::value_type & datum)
 {
   ::DDS::InstanceHandle_t dds_handle;
@@ -41,9 +41,9 @@ CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::
   return dds_handle;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::unregister_instance (
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::unregister_instance (
   const typename DDS_TYPE::value_type & datum,
   const ::DDS::InstanceHandle_t & instance_handle)
 {
@@ -52,10 +52,10 @@ CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::unregiste
   this->impl ()->unregister_instance (datum, handle);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE>::set_impl (
-  CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> *writer)
+CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYPE>::set_impl (
+  CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *writer)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::InstanceHandleManager_T::set_impl");
 
diff --git a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h
index 57bc759e1be..ae31127e930 100644
--- a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h
+++ b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h
@@ -16,7 +16,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class InstanceHandleManager_T :
       public virtual BASE_TYPE,
       public virtual ::CORBA::LocalObject,
@@ -36,7 +36,7 @@ namespace CIAO
         const typename DDS_TYPE::value_type & datum,
         const ::DDS::InstanceHandle_t & instance_handle);
 
-      void set_impl (CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> *writer);
+      void set_impl (CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *writer);
 
       typename DDS_TYPE::data_writer * impl (void);
 
diff --git a/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.cpp b/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.cpp
index 702faa2b693..2176cc5b5ff 100644
--- a/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.cpp
@@ -5,8 +5,8 @@
 #include "dds4ccm/impl/DataReaderHandler_T.h"
 #include "tao/ORB_Core.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::PortStatusListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::PortStatusListener_T (
       ::CCM_DDS::PortStatusListener_ptr port_status_listener,
       ACE_Reactor* reactor)
       : port_status_listener_ (::CCM_DDS::PortStatusListener::_duplicate (port_status_listener)),
@@ -15,15 +15,15 @@ CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::PortStatusListener_T (
   DDS4CCM_TRACE ("CIAO::DDS4CCM::PortStatusListener_T::PortStatusListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::~PortStatusListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~PortStatusListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::PortStatusListener_T::~PortStatusListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed (
   ::DDS::DataReader_ptr the_reader,
   const ::DDS::RequestedDeadlineMissedStatus & status)
 {
@@ -73,9 +73,9 @@ CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_m
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost (
   ::DDS::DataReader_ptr the_reader,
   const ::DDS::SampleLostStatus & status)
 {
@@ -125,48 +125,48 @@ CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos (
   ::DDS::DataReader_ptr ,
   const ::DDS::RequestedIncompatibleQosStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected (
   ::DDS::DataReader_ptr ,
   const ::DDS::SampleRejectedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed (
   ::DDS::DataReader_ptr ,
   const ::DDS::LivelinessChangedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available (
   ::DDS::DataReader_ptr )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched (
   ::DDS::DataReader_ptr ,
   const ::DDS::SubscriptionMatchedStatus & )
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::PortStatusListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   ::CCM_DDS::PortStatusListener_ptr psl)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::PortStatusListener_T::get_mask");
diff --git a/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.h b/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.h
index dc527a67b83..00f7d463551 100644
--- a/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/PortStatusListener_T.h
@@ -21,7 +21,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class PortStatusListener_T :
       public ::DDS::DataReaderListener,
       private ACE_Copy_Disabled
diff --git a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.cpp b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.cpp
index 21cde9204cb..5bb391ce7fd 100644
--- a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.cpp
@@ -7,8 +7,8 @@
 #include "dds4ccm/impl/dds4ccm_conf.h"
 #include "tao/ORB_Core.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::PublisherListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::PublisherListener_T (
   ::CCM_DDS::ConnectorStatusListener_ptr error_listener,
   ACE_Reactor* reactor)
       : error_listener_ (::CCM_DDS::ConnectorStatusListener::_duplicate (error_listener)),
@@ -17,15 +17,15 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::PublisherListener_T (
   DDS4CCM_TRACE ("CIAO::DDS4CCM::PublisherListener_T::PublisherListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::~PublisherListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~PublisherListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::PublisherListener_T::~PublisherListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_unexpected_status (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_unexpected_status (
   ::DDS::Entity_ptr entity,
   ::DDS::StatusKind status_kind)
 {
@@ -67,9 +67,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_unexpected_status (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_missed (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::OfferedDeadlineMissedStatus & status)
 {
@@ -118,9 +118,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_deadline_miss
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_qos (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::OfferedIncompatibleQosStatus & status)
 {
@@ -175,9 +175,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_offered_incompatible_
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::LivelinessLostStatus & status)
 {
@@ -191,9 +191,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_lost (
   this->on_unexpected_status (the_Writer, ::DDS::LIVELINESS_LOST_STATUS);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::PublicationMatchedStatus & status)
 {
@@ -213,9 +213,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_publication_matched (
 }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache_changed (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::ReliableWriterCacheChangedStatus & status)
 {
@@ -247,9 +247,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_writer_cache
   this->on_unexpected_status (the_Writer, ::DDS::RELIABLE_WRITER_CACHE_CHANGED_STATUS);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activity_changed (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed (
   ::DDS::DataWriter_ptr the_Writer,
   const ::DDS::ReliableReaderActivityChangedStatus & status)
 {
@@ -269,9 +269,9 @@ CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::on_reliable_reader_activ
 }
 #endif
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   ::CCM_DDS::ConnectorStatusListener_ptr error_listener)
 {
   if (! ::CORBA::is_nil (error_listener) || CIAO_debug_level >= 10)
diff --git a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
index 5fa0d50523e..78ed9a7d3eb 100644
--- a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
@@ -22,7 +22,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class PublisherListener_T :
       public ::DDS::PublisherListener,
       private ACE_Copy_Disabled
diff --git a/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp b/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp
index 4749993727c..1c27e29736c 100644
--- a/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp
@@ -22,27 +22,27 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_Publisher_T (DDSPublisher * dw)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Publisher_T (DDSPublisher * dw)
       : impl_ (dw)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_Publisher_T");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Publisher_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_Publisher_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Publisher_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_Publisher_T");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Publisher_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::create_datawriter (::DDS::Topic_ptr a_topic,
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter (::DDS::Topic_ptr a_topic,
                                         const ::DDS::DataWriterQos & qos,
                                         ::DDS::DataWriterListener_ptr a_listener,
                                         ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::create_datawriter");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (qos);
@@ -51,7 +51,7 @@ namespace CIAO
 
       if (!topic)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::create_datawriter - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter - "
                        "Error: Unable to cast provided topic to its servant.\n"));
           throw CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
         }
@@ -73,7 +73,7 @@ namespace CIAO
       if (!ccm_dds_dw)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_datawriter - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter - "
                         "Error: RTI Topic returned a nil datawriter.\n"));
           delete ccm_dds_drl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -95,22 +95,22 @@ namespace CIAO
     }
 
 #if (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::create_datawriter_with_profile (::DDS::Topic_ptr a_topic,
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter_with_profile (::DDS::Topic_ptr a_topic,
                                         const char* library_name,
                                         const char *profile_name,
                                         ::DDS::DataWriterListener_ptr a_listener,
                                         ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::create_datawriter");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter");
 
       Topic_type * topic = dynamic_cast < Topic_type * > (a_topic);
 
       if (!topic)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_datawriter_with_profile - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter_with_profile - "
                         "Error: Unable to cast provided topic to its servant.\n"));
           throw CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
         }
@@ -132,7 +132,7 @@ namespace CIAO
       if (!ccm_dds_dw)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_datawriter_with_profile - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter_with_profile - "
                         "Error: RTI Topic returned a nil datawriter.\n"));
           delete ccm_dds_drl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -140,7 +140,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile - "
                         "Successfully created datawriter with profile <%C#%C>.\n",
                         library_name,
                         profile_name));
@@ -156,11 +156,11 @@ namespace CIAO
     }
 #endif
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::delete_datawriter (::DDS::DataWriter_ptr a_datawriter)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter (::DDS::DataWriter_ptr a_datawriter)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::delete_datawriter");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       DataWriter_type *top = dynamic_cast< DataWriter_type * > (a_datawriter);
@@ -168,13 +168,13 @@ namespace CIAO
       if (top == 0)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_datawriter - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter - "
                         "Unable to cast provided object reference to servant.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
 
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_Publisher_T"
-                    "<DDS_TYPE, CCM_TYPE>::delete_datawriter - "
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter - "
                     "Successfully casted provided object reference to servant.\n"));
 
       DDS_ReturnCode_t const retval = this->impl ()->delete_datawriter (top->get_impl ());
@@ -182,14 +182,14 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_datawriter - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter - "
                         "Error: RTI delete_datawriter returned non-ok error code %C\n",
                         translate_retcode (retval)));
         }
       else
         {
           DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_Publisher_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_datawriter - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter - "
                         "Provided datawriter successfully deleted\n"));
         }
 
@@ -199,9 +199,9 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::lookup_datawriter (const char * impl_name)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_datawriter (const char * impl_name)
     {
       ::DDS::DataWriter_var retval = ::DDS::DataWriter::_nil ();
 #if (CIAO_DDS4CCM_NDDS==1)
@@ -218,18 +218,18 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::delete_contained_entities (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
     {
       return this->impl ()->delete_contained_entities ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_qos (const ::DDS::PublisherQos & qos)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::PublisherQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -239,11 +239,11 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_qos (::DDS::PublisherQos & qos)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::PublisherQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -256,12 +256,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_listener (::DDS::PublisherListener_ptr a_listener,
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (::DDS::PublisherListener_ptr a_listener,
                                    ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       PublisherListener_type * ccm_dds_impl_list  = 0;
@@ -277,11 +277,11 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::PublisherListener_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
 #if (CIAO_DDS4CCM_NDDS==1)
       DDSPublisherListener *ccm_dds_pub_list = this->impl ()->get_listener ();
@@ -290,7 +290,7 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_Publisher_T"
-                                    "<DDS_TYPE, CCM_TYPE>::get_listener - "
+                                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                     "DDS returned a NIL listener.\n"));
           return ::DDS::PublisherListener::_nil ();
         }
@@ -300,37 +300,37 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::suspend_publications (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::suspend_publications (void)
     {
       return this->impl ()->suspend_publications ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::resume_publications (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::resume_publications (void)
     {
       return this->impl ()->resume_publications ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::begin_coherent_changes (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::begin_coherent_changes (void)
     {
       return this->impl ()->begin_coherent_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::end_coherent_changes (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::end_coherent_changes (void)
     {
       return this->impl ()->end_coherent_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::wait_for_acknowledgments (
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::wait_for_acknowledgments (
       const ::DDS::Duration_t & max_wait)
     {
 #if (CIAO_DDS4CCM_NDDS==1)
@@ -342,11 +342,11 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_participant (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_participant");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant");
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
 #if (CIAO_DDS4CCM_NDDS==1)
       DDSDomainParticipant* p = this->impl ()->get_participant ();
@@ -362,11 +362,11 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_default_datawriter_qos (const ::DDS::DataWriterQos & qos)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datawriter_qos (const ::DDS::DataWriterQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_default_datawriter_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datawriter_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataWriterQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -376,11 +376,11 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_default_datawriter_qos (::DDS::DataWriterQos & qos)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datawriter_qos (::DDS::DataWriterQos & qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_default_datawriter_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datawriter_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataWriterQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
@@ -392,12 +392,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::copy_from_topic_qos (::DDS::DataWriterQos & a_dataimpl_qos,
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos (::DDS::DataWriterQos & a_dataimpl_qos,
                                               const ::DDS::TopicQos & a_impl_qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::copy_from_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataWriterQos ccm_dds_qos;
       ::DDS_TopicQos ccm_dds_topic_qos;
@@ -413,16 +413,16 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::enable (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
 #if (CIAO_DDS4CCM_NDDS==1)
@@ -439,16 +439,16 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
     {
       return this->impl ()->get_status_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
 #if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
@@ -460,23 +460,23 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSPublisher *
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSPublisher * dw)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSPublisher * dw)
     {
       this->impl_ = dw;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSPublisher *
-    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/Publisher_T.h b/CIAO/connectors/dds4ccm/impl/Publisher_T.h
index 00320107906..bba36279f6b 100644
--- a/CIAO/connectors/dds4ccm/impl/Publisher_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Publisher_T.h
@@ -31,30 +31,30 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriter_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Publisher_T :
       public virtual ::DDS::CCM_Publisher,
       public virtual ::CORBA::LocalObject
     {
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
 
-    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE> DataWriter_type;
-    typedef CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE> DataWriterListener_type;
+    typedef CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriter_type;
+    typedef CCM_DDS_DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataWriterListener_type;
 
-    typedef CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE> PublisherListener_type;
-    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> PublisherListener_type;
+    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
     public:
       /// Constructor
       CCM_DDS_Publisher_T (DDSPublisher * dw);
diff --git a/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp
index b64e4a0ce2c..66a9ca5ea1f 100644
--- a/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp
@@ -13,51 +13,50 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_QueryCondition_T (DDSQueryCondition * qc)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_QueryCondition_T (DDSQueryCondition * qc)
       : impl_ (qc)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_QueryCondition_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_QueryCondition_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::CORBA::Boolean
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_trigger_value (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_trigger_value (void)
     {
       return this->impl ()->get_trigger_value ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SampleStateMask
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_sample_state_mask (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
     {
       return this->impl ()->get_sample_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ViewStateMask
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_view_state_mask (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
     {
       return this->impl ()->get_view_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceStateMask
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_instance_state_mask (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
     {
       return this->impl ()->get_instance_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_datareader (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader (void)
     {
       ::DDS::DataReader_var dds_reader = ::DDS::DataReader::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDataReader* reader = this->impl ()->get_datareader ();
       if (reader)
         {
@@ -65,76 +64,55 @@ namespace CIAO
                             DataReader_type (reader),
                             CORBA::NO_MEMORY ());
         }
-#else
-      ::DDS::DataReader_var reader = this->impl ()->get_datareader ();
-      if (! ::CORBA::is_nil (reader.in ()))
-        {
-          ACE_NEW_THROW_EX (dds_reader,
-                            DataReader_type (reader.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return dds_reader._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_query_expression (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_query_expression (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return ::CORBA::string_dup (this->impl ()->get_query_expression ());
-#else
-      return this->impl ()->get_query_expression ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_query_parameters (
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_query_parameters (
       ::DDS::StringSeq & query_parameters)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_StringSeq parameters;
       ::DDS::ReturnCode_t const retval =
         this->impl ()->get_query_parameters (parameters);
       query_parameters <<= parameters;
       return retval;
-#else
-      return this->impl ()->get_query_parameters (query_parameters);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::set_query_parameters (
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_query_parameters (
       const ::DDS::StringSeq & query_parameters)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_StringSeq parameters;
       parameters <<= query_parameters;
       return this->impl ()->set_query_parameters (parameters);
-#else
-      return this->impl ()->set_query_parameters (query_parameters);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSQueryCondition *
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSQueryCondition * dw)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSQueryCondition * dw)
     {
       this->impl_ = dw;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSQueryCondition *
-    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h
index d7a5d4a37d0..3e03243a7f1 100644
--- a/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h
+++ b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h
@@ -31,15 +31,15 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_QueryCondition_T :
       public virtual ::DDS::CCM_QueryCondition,
       public virtual ::CORBA::LocalObject
     {
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp
index 19216292045..6cb89c45a6c 100644
--- a/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp
@@ -6,48 +6,48 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_ReadCondition_T (DDSReadCondition * rc)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_ReadCondition_T (DDSReadCondition * rc)
       : impl_ (rc)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_ReadCondition_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_ReadCondition_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::CORBA::Boolean
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_trigger_value (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_trigger_value (void)
     {
       return this->impl ()->get_trigger_value ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SampleStateMask
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_sample_state_mask (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
     {
       return this->impl ()->get_sample_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ViewStateMask
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_view_state_mask (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
     {
       return this->impl ()->get_view_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceStateMask
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_instance_state_mask (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
     {
       return this->impl ()->get_instance_state_mask ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_datareader (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader (void)
     {
       ::DDS::DataReader_var retval = ::DDS::DataReader::_nil ();
       DDSDataReader* rd = this->impl ()->get_datareader ();
@@ -60,23 +60,23 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSReadCondition *
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSReadCondition * rc)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSReadCondition * rc)
     {
       this->impl_ = rc;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSReadCondition *
-    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h
index 8a7a31fb54f..810fd1be3f2 100644
--- a/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h
+++ b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h
@@ -31,15 +31,15 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ReadCondition_T :
       public virtual ::DDS::CCM_ReadCondition,
       public virtual ::CORBA::LocalObject
     {
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/Reader_T.cpp b/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
index e4f6475fd5c..31c67283cd1 100644
--- a/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
@@ -8,15 +8,15 @@
 
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::Reader_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::Reader_T (void)
   : reader_ (0)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Reader_T::Reader_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::~Reader_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::~Reader_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Reader_T::~Reader_T");
 }
@@ -24,9 +24,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::~Reader_T (void)
 /// For the requirement : 'samples ordered by instances' the following settings 
 /// are necessary: ordered_access -> true and
 /// DDS_INSTANCE_PRESENTATION_QOS (default)
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 CORBA::ULong
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::get_nr_valid_samples (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::get_nr_valid_samples (
   const DDS_SampleInfoSeq& sample_info,
   bool determine_last)
 {
@@ -48,9 +48,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::get_nr_valid_sample
   return nr_of_samples;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_last (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::read_last (
   typename CCM_TYPE::seq_type& instances,
   ::CCM_DDS::ReadInfoSeq& infos)
 {
@@ -96,9 +96,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_last (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_all (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::read_all (
           typename CCM_TYPE::seq_type& instances,
           ::CCM_DDS::ReadInfoSeq& infos)
 {
@@ -141,9 +141,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_all (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_InstanceHandle_t
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::check_handle (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::check_handle (
   const typename DDS_TYPE::value_type& an_instance,
   const ::DDS::InstanceHandle_t & instance_handle)
 {
@@ -164,9 +164,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::check_handle (
   return lookup_hnd;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_one_last (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::read_one_last (
   typename DDS_TYPE::value_type& an_instance,
   ::CCM_DDS::ReadInfo_out info,
   const ::DDS::InstanceHandle_t & instance_handle)
@@ -208,9 +208,9 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_one_last (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_one_all (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::read_one_all (
   const typename DDS_TYPE::value_type& an_instance,
   typename CCM_TYPE::seq_type& instances,
   ::CCM_DDS::ReadInfoSeq& infos,
@@ -261,51 +261,51 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::read_one_all (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CCM_DDS::QueryFilter *
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::query (void)
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::query (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Reader_T::query");
   return this->impl ()->query ();
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::query (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::query (
   const ::CCM_DDS::QueryFilter & query)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Reader_T::query");
   return this->impl ()->query (query);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::set_impl (
-  DataReader_T<DDS_TYPE, CCM_TYPE> * dr)
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::set_impl (
+  DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * dr)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_CCM::Reader_T::set_impl");
 
   this->reader_ = dr;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 ::CORBA::Object_ptr
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::_get_component (void)
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::_get_component (void)
 {
   return CCM_TYPE::base_type::_duplicate (this->component_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::_set_component (
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::_set_component (
   typename CCM_TYPE::base_type::_ptr_type component)
 {
   this->component_ = CCM_TYPE::base_type::_duplicate (component);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE> *
-CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED>::impl (void)
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *
+CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::impl (void)
 {
   if (this->reader_)
     {
diff --git a/CIAO/connectors/dds4ccm/impl/Reader_T.h b/CIAO/connectors/dds4ccm/impl/Reader_T.h
index 75a42377cbc..3ffb14bdf3f 100644
--- a/CIAO/connectors/dds4ccm/impl/Reader_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Reader_T.h
@@ -25,7 +25,7 @@ namespace CIAO
   {
     namespace DDS_CCM
     {
-      template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+      template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
       class Reader_T :
           public virtual CCM_TYPE::reader_type,
           public virtual ::CORBA::LocalObject,
@@ -64,13 +64,13 @@ namespace CIAO
 
         virtual void query (const ::CCM_DDS::QueryFilter & filter);
 
-        void set_impl (DataReader_T<DDS_TYPE, CCM_TYPE> * dr);
+        void set_impl (DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * dr);
 
       private:
-        DataReader_T<DDS_TYPE, CCM_TYPE> * reader_;
+        DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * reader_;
         typename CCM_TYPE::base_type::_var_type component_;
 
-        DataReader_T<DDS_TYPE, CCM_TYPE> * impl (void);
+        DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> * impl (void);
 
         DDS_InstanceHandle_t check_handle (
           const typename DDS_TYPE::value_type& an_instance,
diff --git a/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp
index 7d8ea2935e5..9c5a74e24e7 100644
--- a/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp
@@ -4,8 +4,8 @@
 #include "dds4ccm/impl/Utils.h"
 #include "tao/ORB_Core.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::SubscriberListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::SubscriberListener_T (
   ::CCM_DDS::ConnectorStatusListener_ptr error_listener,
   ACE_Reactor* reactor)
     : error_listener_ (::CCM_DDS::ConnectorStatusListener::_duplicate (error_listener)),
@@ -14,15 +14,15 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::SubscriberListener_T (
   DDS4CCM_TRACE ("CIAO::DDS4CCM::SubscriberListener_T::SubscriberListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::~SubscriberListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~SubscriberListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::SubscriberListener_T::~SubscriberListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatible_qos (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos (
   ::DDS::DataReader_ptr reader,
   const ::DDS::RequestedIncompatibleQosStatus & status)
 {
@@ -79,9 +79,9 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_incompatib
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_unexpected_status (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_unexpected_status (
   ::DDS::Entity_ptr entity,
   ::DDS::StatusKind status_kind)
 {
@@ -125,9 +125,9 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_unexpected_status (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed (
   ::DDS::DataReader* reader,
   const ::DDS::LivelinessChangedStatus& status)
 {
@@ -146,9 +146,9 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_liveliness_changed (
   this->on_unexpected_status (reader, ::DDS::LIVELINESS_CHANGED_STATUS);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected (
   ::DDS::DataReader_ptr reader,
   const ::DDS::SampleRejectedStatus& status)
 {
@@ -201,9 +201,9 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_rejected (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched(
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched(
   ::DDS::DataReader* reader,
   const ::DDS::SubscriptionMatchedStatus& status)
 {
@@ -222,41 +222,41 @@ CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_subscription_matched
   this->on_unexpected_status (reader, ::DDS::SUBSCRIPTION_MATCHED_STATUS);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_on_readers(
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_on_readers(
   ::DDS::Subscriber *)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::SubscriberListener_T::on_data_on_readers");
   //do nothing by design
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_requested_deadline_missed (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed (
   ::DDS::DataReader_ptr,
   const ::DDS::RequestedDeadlineMissedStatus &)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_data_available (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available (
   ::DDS::DataReader_ptr)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::on_sample_lost (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost (
   ::DDS::DataReader_ptr,
   const ::DDS::SampleLostStatus &)
 {
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   ::CCM_DDS::ConnectorStatusListener_ptr csl)
 {
   if (! ::CORBA::is_nil (csl) || CIAO_debug_level >= 10)
diff --git a/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h
index 04e065ccc1b..073cf8da971 100644
--- a/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h
@@ -22,7 +22,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class SubscriberListener_T :
       public ::DDS::CCM_SubscriberListener,
       private ACE_Copy_Disabled
diff --git a/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp b/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp
index 99afb3fdb31..3a2ba2e84c7 100644
--- a/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp
@@ -22,29 +22,29 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_Subscriber_T (DDSSubscriber * sub)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Subscriber_T (DDSSubscriber * sub)
       : impl_ (sub)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_Subscriber_T");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Subscriber_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_Subscriber_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Subscriber_T (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_Subscriber_T");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Subscriber_T");
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::enable (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
@@ -67,16 +67,16 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
     {
       return this->impl ()->get_status_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
@@ -88,9 +88,9 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
                   DDSContentFilteredTopic * topic,
                   DDSDataReaderListener * ccm_dds_drl,
                   ::DDS::StatusMask mask,
@@ -111,9 +111,9 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
                   DDSTopic * topic,
                   DDSDataReaderListener * ccm_dds_drl,
                   ::DDS::StatusMask mask,
@@ -135,9 +135,9 @@ namespace CIAO
     }
 
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile (
                   DDSContentFilteredTopic * topic,
                   const char * library_name,
                   const char * profile_name,
@@ -153,9 +153,9 @@ namespace CIAO
 #endif
 
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile (
                   DDSTopic * topic,
                   const char * library_name,
                   const char * profile_name,
@@ -170,15 +170,15 @@ namespace CIAO
     }
 #endif
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
       ::DDS::TopicDescription_ptr a_topic,
       const ::DDS::DataReaderQos & qos,
       ::DDS::DataReaderListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader");
       ::DDS::DataReader_var retval = ::DDS::DataReader::_nil ();
       DDSDataReaderListener *ccm_dds_drl = 0;
       if (! ::CORBA::is_nil (a_listener))
@@ -198,7 +198,7 @@ namespace CIAO
           if (!cf_topic)
             {
               DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T"
-                          "<DDS_TYPE, CCM_TYPE>::create_datareader - "
+                          "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader - "
                           "Error: Unable to cast provided topic to one of its servant.\n"));
               delete ccm_dds_drl;
               throw CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
@@ -218,7 +218,7 @@ namespace CIAO
       if (!ccm_dds_dr)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T"
-                       "<DDS_TYPE, CCM_TYPE>::create_datareader - "
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader - "
                        "Error: RTI Topic returned a nil datareader.\n"));
           delete ccm_dds_drl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -226,7 +226,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_Subscriber_T"
-                        "<DDS_TYPE, CCM_TYPE>::create_datareader - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader - "
                         "Successfully created datareader.\n"));
         }
 
@@ -237,16 +237,16 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile (
       ::DDS::TopicDescription_ptr a_topic,
       const char * library_name,
       const char * profile_name,
       ::DDS::DataReaderListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile");
       DDSDataReaderListener *ccm_dds_drl = 0;
       if (! ::CORBA::is_nil (a_listener))
         {
@@ -264,7 +264,7 @@ namespace CIAO
             dynamic_cast < ContentFilteredTopic_type * > (a_topic);
           if (!cf_topic)
             {
-              DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile - "
+              DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile - "
                           "Error: Unable to cast provided topic to one of its servant.\n"));
               delete ccm_dds_drl;
               throw CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
@@ -289,14 +289,14 @@ namespace CIAO
 
       if (!ccm_dds_dr)
         {
-          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile - "
+          DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile - "
                        "Error: RTI Topic returned a nil datareader.\n"));
           delete ccm_dds_drl;
           throw CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
         }
       else
         {
-          DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::create_datareader_with_profile - "
+          DDS4CCM_DEBUG (6, (LM_DEBUG, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader_with_profile - "
                        "Successfully created datareader with profile <%C#%C>.\n",
                        library_name,
                        profile_name));
@@ -312,22 +312,22 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::delete_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader (
       ::DDS::DataReader_ptr a_datareader)
     {
       DataReader_type *dr = dynamic_cast< DataReader_type *> (a_datareader);
       if (!dr)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_datareader - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader - "
                         "Unable to cast provided object reference to servant.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
 
       DDS4CCM_DEBUG (9, (LM_TRACE, CLINFO "CCM_DDS_Subscriber_T"
-                    "<DDS_TYPE, CCM_TYPE>::delete_datareader - "
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader - "
                     "Successfully casted provided object reference to servant.\n"));
 
       DDS_ReturnCode_t const retval = this->impl ()->delete_datareader (dr->get_impl ());
@@ -335,29 +335,29 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (1, (LM_ERROR, CLINFO "CCM_DDS_Subscriber_T"
-                        "<DDS_TYPE, CCM_TYPE>::delete_datareader - "
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader - "
                         "Error: Returned non-ok error code %C\n",
                         translate_retcode (retval)));
         }
       else
         {
-          DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::delete_datareader - "
+          DDS4CCM_DEBUG (6, (LM_INFO, CLINFO "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader - "
                         "Datareader successfully  deleted\n"));
         }
 
       return retval;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::delete_contained_entities (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
     {
       return this->impl ()->delete_contained_entities ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::lookup_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_datareader (
       const char * impl_name)
     {
       ::DDS::DataReader_var retval = ::DDS::DataReader::_nil ();
@@ -371,15 +371,15 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_datareaders (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareaders (
       ::DDS::DataReaderSeq & readers,
       ::DDS::SampleStateMask sample_states,
       ::DDS::ViewStateMask view_states,
       ::DDS::InstanceStateMask instance_states)
     {
-      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_qos");
+      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDSDataReaderSeq dds_readers;
 
@@ -409,19 +409,19 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::notify_datareaders (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::notify_datareaders (void)
     {
       return this->impl ()->notify_datareaders ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
       const ::DDS::SubscriberQos & qos)
     {
-      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_qos");
+      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_SubscriberQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -431,12 +431,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
       ::DDS::SubscriberQos & qos)
     {
-      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_qos");
+      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_SubscriberQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl ()->get_qos (ccm_dds_qos);
@@ -447,13 +447,13 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_listener (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
       ::DDS::SubscriberListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
       SubscriberListener_type * ccm_dds_impl_list = 0;
       if (! ::CORBA::is_nil (a_listener))
@@ -465,41 +465,41 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SubscriberListener_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
       DDSSubscriberListener *ccm_dds_impl_list = this->impl ()->get_listener ();
       SubscriberListener_type *list_proxy =
         dynamic_cast <SubscriberListener_type *> (ccm_dds_impl_list);
       if (!list_proxy)
         {
-          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_listener - "
+          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                     "DDS returned a NIL listener.\n"));
           return ::DDS::SubscriberListener::_nil ();
         }
       return list_proxy->get_subscriber_listener ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::begin_access (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::begin_access (void)
     {
       return this->impl ()->begin_access ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::end_access (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::end_access (void)
     {
       return this->impl ()->end_access ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_participant (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
@@ -522,12 +522,12 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_default_datareader_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datareader_qos (
       const ::DDS::DataReaderQos & qos)
     {
-      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_default_datareader_qos");
+      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datareader_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataReaderQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
@@ -537,12 +537,12 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_default_datareader_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datareader_qos (
       ::DDS::DataReaderQos & qos)
     {
-      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_default_datareader_qos");
+      CIAO_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datareader_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataReaderQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl ()->get_default_datareader_qos (ccm_dds_qos);
@@ -553,13 +553,13 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::copy_from_topic_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos (
       ::DDS::DataReaderQos & a_datareader_qos,
       const ::DDS::TopicQos & a_impl_qos)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::copy_from_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
 #if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DataReaderQos ccm_dds_qos;
       ::DDS_TopicQos ccm_dds_topic_qos;
@@ -577,23 +577,23 @@ namespace CIAO
 #endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSSubscriber *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSSubscriber * sub)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSSubscriber * sub)
     {
       this->impl_ = sub;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSSubscriber *
-    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/Subscriber_T.h b/CIAO/connectors/dds4ccm/impl/Subscriber_T.h
index 0904e0ec15e..05c81368e19 100644
--- a/CIAO/connectors/dds4ccm/impl/Subscriber_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Subscriber_T.h
@@ -35,36 +35,36 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataReaderListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Subscriber_T :
       public virtual ::DDS::CCM_Subscriber,
       public virtual ::CORBA::LocalObject
     {
 
-    typedef CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE> DataReaderListener_type;
-    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE> Topic_type;
-    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE> ContentFilteredTopic_type;
-    typedef DataReader_T<DDS_TYPE, CCM_TYPE> DataReader_type;
-    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE> SubscriberListener_type;
-    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReaderListener_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
+    typedef CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> ContentFilteredTopic_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
+    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> SubscriberListener_type;
+    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp
index b337ccbbeca..c4366841f80 100644
--- a/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp
@@ -10,45 +10,36 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_TopicDescription_T (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_TopicDescription_T (
       DDSTopicDescription * rc) : impl_ (rc)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_TopicDescription_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_TopicDescription_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::get_type_name (void)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_type_name ());
-#else
-      return this->impl ()->get_type_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::get_name (void)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_name ());
-#else
-      return this->impl ()->get_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::get_participant (void)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDomainParticipant* p = this->impl ()->get_participant ();
       if (p)
         {
@@ -56,35 +47,26 @@ namespace CIAO
                             DomainParticipant_type (p),
                             CORBA::NO_MEMORY ());
         }
-#else
-      ::DDS::DomainParticipant_var p = this->impl ()->get_participant ();
-      if (! ::CORBA::is_nil (p.in ()))
-        {
-          ACE_NEW_THROW_EX (retval,
-                            DomainParticipant_type (p.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopicDescription *
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSTopicDescription * rc)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSTopicDescription * rc)
     {
       this->impl_ = rc;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopicDescription *
-    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h
index d682f7e2e4b..24efd9e35a7 100644
--- a/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h
+++ b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h
@@ -31,15 +31,15 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_TopicDescription_T :
       public virtual ::DDS::CCM_TopicDescription,
       public virtual ::CORBA::LocalObject
     {
-    typedef CCM_DDS_DomainParticipant<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_DomainParticipant<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp b/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
index 624c2c46c92..35a1b33d8b6 100644
--- a/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
@@ -5,8 +5,8 @@
 #include "dds4ccm/impl/DDSCallbackStatusHandler.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::TopicListener_T (
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::TopicListener_T (
   ::CCM_DDS::ConnectorStatusListener_ptr error_listener,
   ACE_Reactor* reactor) :
     error_listener_ (::CCM_DDS::ConnectorStatusListener::_duplicate (error_listener)),
@@ -15,15 +15,15 @@ CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::TopicListener_T (
   DDS4CCM_TRACE ("CIAO::DDS4CCM::TopicListener_T::TopicListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::~TopicListener_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~TopicListener_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::TopicListener_T::~TopicListener_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::on_inconsistent_topic (
+CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_inconsistent_topic (
   ::DDS::Topic_ptr the_topic,
   const ::DDS::InconsistentTopicStatus & status)
 {
@@ -59,9 +59,9 @@ CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::on_inconsistent_topic (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE>::get_mask (
+CIAO::DDS4CCM::TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (
   CCM_DDS::ConnectorStatusListener_ptr error_listener)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::TopicListener_T::get_mask");
diff --git a/CIAO/connectors/dds4ccm/impl/TopicListener_T.h b/CIAO/connectors/dds4ccm/impl/TopicListener_T.h
index f2a0cb95694..16783a22095 100644
--- a/CIAO/connectors/dds4ccm/impl/TopicListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/TopicListener_T.h
@@ -19,7 +19,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class TopicListener_T :
       public ::DDS::TopicListener,
       private ACE_Copy_Disabled
diff --git a/CIAO/connectors/dds4ccm/impl/Topic_T.cpp b/CIAO/connectors/dds4ccm/impl/Topic_T.cpp
index 3f9657f374c..14d969447bb 100644
--- a/CIAO/connectors/dds4ccm/impl/Topic_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Topic_T.cpp
@@ -16,53 +16,44 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::CCM_DDS_Topic_T (DDSTopic* topic)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Topic_T (DDSTopic* topic)
       : impl_ (topic)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::~CCM_DDS_Topic_T (void)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Topic_T (void)
     {
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::set_qos (const ::DDS::TopicQos &qos)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::TopicQos &qos)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_TopicQos ddsqos;
       ddsqos <<= qos;
       return this->impl ()->set_qos (ddsqos);
-#else
-      return this->impl ()->set_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_qos (::DDS::TopicQos &qos)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::TopicQos &qos)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_TopicQos ddsqos;
       ::DDS_ReturnCode_t const retval = this->impl ()->get_qos (ddsqos);
       qos <<= ddsqos;
       return retval;
-#else
-      return this->impl ()->get_qos (qos);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::set_listener (
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
       ::DDS::TopicListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       TopicListener_type *ccm_dds_impl_list = 0;
       if (! ::CORBA::is_nil (a_listener))
         {
@@ -71,125 +62,94 @@ namespace CIAO
                             CORBA::NO_MEMORY ());
         }
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
-#else
-      return this->impl ()->set_listener (a_listener, mask);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicListener_ptr
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_listener (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSTopicListener *ccm_dds_topic_list = this->impl ()->get_listener ();
       TopicListener_type * list_proxy =
         dynamic_cast <TopicListener_type *> (ccm_dds_topic_list);
       if (!list_proxy)
         {
-          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_listener - "
+          DDS4CCM_DEBUG (6, (LM_DEBUG, "CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener - "
                                     "DDS returned a NIL listener.\n"));
           return ::DDS::TopicListener::_nil ();
         }
       return list_proxy->get_topiclistener ();
-#else
-      return this->impl ()->get_listener ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_inconsistent_topic_status (
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_inconsistent_topic_status (
       ::DDS::InconsistentTopicStatus & a_status)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       DDS_InconsistentTopicStatus ddsstatus;
       ::DDS::ReturnCode_t const retval =
         this->impl ()->get_inconsistent_topic_status (ddsstatus);
       a_status <<= ddsstatus;;
       return retval;
-#else
-      return this->impl ()->get_inconsistent_topic_status (a_status);
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::enable (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_statuscondition (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval = ::DDS::StatusCondition::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       ACE_NEW_THROW_EX (retval,
                         CCM_DDS_StatusCondition_i (sc),
                         CORBA::NO_MEMORY ());
-#else
-      ::DDS::StatusCondition_var sc = this->impl ()->get_statuscondition ();
-      ACE_NEW_THROW_EX (retval,
-                        CCM_DDS_StatusCondition_i (sc.in ()),
-                        CORBA::NO_MEMORY ());
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_status_changes (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
     {
       return this->impl ()->get_status_changes ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_instance_handle (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_InstanceHandle_t const rtihandle =
         this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
       handle <<= rtihandle;
       return handle;
-#else
-      return this->impl ()->get_instance_handle ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_type_name (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_type_name ());
-#else
-      return this->impl ()->get_type_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_name (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
     {
-#if (CIAO_DDS4CCM_NDDS==1)
       return CORBA::string_dup (this->impl ()->get_name ());
-#else
-      return this->impl ()->get_name ();
-#endif
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_participant (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval = ::DDS::DomainParticipant::_nil ();
-#if (CIAO_DDS4CCM_NDDS==1)
       DDSDomainParticipant * p = this->impl ()->get_participant ();
       if (p)
         {
@@ -197,35 +157,26 @@ namespace CIAO
                             DomainParticipant_type (p),
                             CORBA::NO_MEMORY ());
         }
-#else
-      ::DDS::DomainParticipant_var p = this->impl ()->get_participant ();
-      if (! ::CORBA::is_nil (p.in ()))
-        {
-          ACE_NEW_THROW_EX (retval,
-                            DomainParticipant_type (p.in ()),
-                            CORBA::NO_MEMORY ());
-        }
-#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopic *
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::get_impl (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::set_impl (DDSTopic * topic)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSTopic * topic)
     {
       this->impl_ = topic;
     }
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopic *
-    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE>::impl (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/Topic_T.h b/CIAO/connectors/dds4ccm/impl/Topic_T.h
index 72ecbf54be4..d42b0961dfd 100644
--- a/CIAO/connectors/dds4ccm/impl/Topic_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Topic_T.h
@@ -22,16 +22,16 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_Topic_T :
       public virtual ::DDS::CCM_Topic,
       public virtual ::CORBA::LocalObject
     {
-    typedef CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE> TopicListener_type;
-    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> TopicListener_type;
+    typedef CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
 
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/Updater_T.cpp b/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
index 559720f4828..89f372d8b75 100644
--- a/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
@@ -5,48 +5,48 @@
 #include "dds4ccm/impl/Coherent_Changes_Guard.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::Updater_T (void)
-  : InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, typename CCM_TYPE::updater_type> (),
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::Updater_T (void)
+  : InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, typename CCM_TYPE::updater_type, VENDOR_TYPE> (),
     is_global_scope_ (false),
     is_coherent_write_ (false)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::Updater_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::~Updater_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~Updater_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::~Updater_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::is_global_scope ()
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::is_global_scope ()
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::is_global_scope");
   return this->is_global_scope_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 bool
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::is_coherent_write ()
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::is_coherent_write ()
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::is_coherent_write");
   return this->is_coherent_write_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::is_coherent_write (bool value)
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::is_coherent_write (bool value)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::is_coherent_write");
   this->is_coherent_write_ = value;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_i (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_i (
   const typename DDS_TYPE::value_type & an_instance,
   ::CCM_DDS::DataNumber_t index)
 {
@@ -70,9 +70,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_i (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_one (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_one (
   const typename DDS_TYPE::value_type & an_instance)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::create_one");
@@ -85,9 +85,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_one (
   this->create_i (an_instance, 0);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_i (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::update_i (
   const typename DDS_TYPE::value_type & an_instance,
   const ::DDS::InstanceHandle_t & instance_handle,
   ::CCM_DDS::DataNumber_t index)
@@ -106,9 +106,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_i (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_one (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::update_one (
   const typename DDS_TYPE::value_type & an_instance,
   const ::DDS::InstanceHandle_t & instance_handle)
 {
@@ -138,9 +138,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_one (
   this->update_i (an_instance, instance_handle, 0);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_i (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_i (
   const typename DDS_TYPE::value_type & an_instance,
   const ::DDS::InstanceHandle_t & instance_handle,
   ::CCM_DDS::DataNumber_t index)
@@ -168,9 +168,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_i (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_one (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_one (
   const typename DDS_TYPE::value_type & an_instance,
   const ::DDS::InstanceHandle_t & instance_handle)
 {
@@ -200,9 +200,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_one (
   this->delete_i (an_instance, instance_handle, 0);
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_many (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_many (
   const typename CCM_TYPE::seq_type& data)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::create_many");
@@ -219,9 +219,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::create_many (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::check_existent (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::check_existent (
   const typename CCM_TYPE::seq_type& data)
 {
   ::CCM_DDS::NonExistent exception;
@@ -243,9 +243,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::check_existent (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::check_already_created (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::check_already_created (
   const typename CCM_TYPE::seq_type& data)
 {
   ::CCM_DDS::AlreadyCreated exception;
@@ -267,9 +267,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::check_already_created (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_many (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::update_many (
   const typename CCM_TYPE::seq_type& data)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::update_many");
@@ -286,9 +286,9 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::update_many (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_many (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_many (
   const typename CCM_TYPE::seq_type& data)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Updater_T::delete_many");
@@ -305,16 +305,16 @@ CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::delete_many (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CORBA::Object_ptr
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::_get_component (void)
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_get_component (void)
 {
   return CCM_TYPE::base_type::_duplicate (this->component_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE>::_set_component (
+CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_set_component (
   typename CCM_TYPE::base_type::_ptr_type component)
 {
   this->component_ = CCM_TYPE::base_type::_duplicate (component);
diff --git a/CIAO/connectors/dds4ccm/impl/Updater_T.h b/CIAO/connectors/dds4ccm/impl/Updater_T.h
index ed7bb25f16a..9eb6c370bff 100644
--- a/CIAO/connectors/dds4ccm/impl/Updater_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Updater_T.h
@@ -17,9 +17,9 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class Updater_T :
-      public InstanceHandleManager_T <DDS_TYPE, CCM_TYPE, typename CCM_TYPE::updater_type>
+      public InstanceHandleManager_T <DDS_TYPE, CCM_TYPE, typename CCM_TYPE::updater_type, VENDOR_TYPE>
     {
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/Writer_T.cpp b/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
index 784938637ef..21a9b6571c1 100644
--- a/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
@@ -7,23 +7,23 @@
 #include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
-template <typename DDS_TYPE, typename CCM_TYPE >
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::Writer_T (void)
-  : InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, typename CCM_TYPE::writer_type> (),
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::Writer_T (void)
+  : InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, typename CCM_TYPE::writer_type, VENDOR_TYPE> (),
     is_coherent_write_ (false)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Writer_T::Writer_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::~Writer_T (void)
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~Writer_T (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Writer_T::~Writer_T");
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_i (
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::write_i (
   const typename DDS_TYPE::value_type& datum,
   const ::DDS::InstanceHandle_t& instance_handle,
   ::CCM_DDS::DataNumber_t index)
@@ -43,9 +43,9 @@ CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_i (
     }
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_one (
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::write_one (
   const typename DDS_TYPE::value_type & an_instance,
   const ::DDS::InstanceHandle_t & instance_handle)
 {
@@ -57,9 +57,9 @@ CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_one (
                "Write successful\n"));
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_many (
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::write_many (
   const typename CCM_TYPE::seq_type& instances)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::Writer_T::write_many");
@@ -81,31 +81,31 @@ CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::write_many (
                "Write successful\n"));
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CORBA::Boolean
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::is_coherent_write (void)
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::is_coherent_write (void)
 {
   return this->is_coherent_write_;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE >
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::is_coherent_write (
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::is_coherent_write (
   ::CORBA::Boolean value)
 {
   this->is_coherent_write_ = value;
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::CORBA::Object_ptr
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::_get_component (void)
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_get_component (void)
 {
   return CCM_TYPE::base_type::_duplicate (this->component_.in ());
 }
 
-template <typename DDS_TYPE, typename CCM_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE>::_set_component (
+CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::_set_component (
   typename CCM_TYPE::base_type::_ptr_type component)
 {
   this->component_ = CCM_TYPE::base_type::_duplicate (component);
diff --git a/CIAO/connectors/dds4ccm/impl/Writer_T.h b/CIAO/connectors/dds4ccm/impl/Writer_T.h
index 76920fb84db..7e5dd397ab3 100644
--- a/CIAO/connectors/dds4ccm/impl/Writer_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Writer_T.h
@@ -18,9 +18,9 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, typename CCM_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class Writer_T :
-      public InstanceHandleManager_T <DDS_TYPE, CCM_TYPE, typename CCM_TYPE::writer_type>
+      public InstanceHandleManager_T <DDS_TYPE, CCM_TYPE, typename CCM_TYPE::writer_type, VENDOR_TYPE>
     {
     public:
       /// Constructor
diff --git a/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h b/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
index 01dbe542943..ab6b18e9f17 100644
--- a/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
+++ b/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
@@ -17,4 +17,9 @@
 #  define CIAO_DDS4CCM_CONTEXT_SWITCH 1
 #endif /* CIAO_DDS4CCM_CONTEXT_SWITCH */
 
+enum DDS4CCM_Vendor
+{
+  DDS4CCM_NDDS
+};
+
 #endif /* DDS4CCM_CONF_H_ */
diff --git a/CIAO/connectors/dds4ccm/tests/PSAT/DDS_PSAT_Connector_T.h b/CIAO/connectors/dds4ccm/tests/PSAT/DDS_PSAT_Connector_T.h
index afc420690b3..979c5d1c0f1 100644
--- a/CIAO/connectors/dds4ccm/tests/PSAT/DDS_PSAT_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/tests/PSAT/DDS_PSAT_Connector_T.h
@@ -5,9 +5,9 @@
 
 #include "connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h"
 
-template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED>
+template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_PSAT_Event_Connector_T
-  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE>
+  : public virtual DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
 {
   virtual
   typename CCM_TYPE::psat_writer_type::_ptr_type