Fri Oct 29 11:33:06 UTC 2010 Marcel Smit <msmit@remedy.nl>

        * MPC/config/dds4ccm_impl.mpb:
        * connectors/dds4ccm/impl/*:
          Reverted previous commit.

135 files changed, 2101 insertions, 1607 deletions

diff --git a/CIAO/ChangeLog b/CIAO/ChangeLog
index e8624b00154..1ead746c164 100644
--- a/CIAO/ChangeLog
+++ b/CIAO/ChangeLog
@@ -1,3 +1,9 @@
+Fri Oct 29 11:33:06 UTC 2010  Marcel Smit  <msmit@remedy.nl>
+
+        * MPC/config/dds4ccm_impl.mpb:
+        * connectors/dds4ccm/impl/*:
+          Reverted previous commit.
+
 Fri Oct 29 10:33:50 UTC 2010  Marcel Smit  <msmit@remedy.nl>
 
         * MPC/config/dds4ccm_impl.mpb:
diff --git a/CIAO/MPC/config/dds4ccm_impl.mpb b/CIAO/MPC/config/dds4ccm_impl.mpb
index 6c6e64212ee..6c80345aa20 100644
--- a/CIAO/MPC/config/dds4ccm_impl.mpb
+++ b/CIAO/MPC/config/dds4ccm_impl.mpb
@@ -12,8 +12,8 @@ feature(dds4ccm_splice) : dds4ccm_skel, dds4ccm_lem_stub {
 }
 
 feature(dds4ccm_ndds) : dds4ccm_skel, dds4ccm_lem_stub, nddslib {
-  after += CIAO_DDS4CCM_DDS_Impl CIAO_DDS4CCM_DDS_NDDS
-  libs += CIAO_DDS4CCM_DDS_Impl CIAO_DDS4CCM_DDS_NDDS
+  after += CIAO_DDS4CCM_DDS_Impl
+  libs += CIAO_DDS4CCM_DDS_Impl
 }
 
 feature(!dds4ccm_opendds, !dds4ccm_ndds, !dds4ccm_splice) {
diff --git a/CIAO/connectors/dds4ccm/impl/Coherent_Changes_Guard.h b/CIAO/connectors/dds4ccm/impl/Coherent_Changes_Guard.h
index 4e1d3929dfd..eb350ffe3b8 100644
--- a/CIAO/connectors/dds4ccm/impl/Coherent_Changes_Guard.h
+++ b/CIAO/connectors/dds4ccm/impl/Coherent_Changes_Guard.h
@@ -17,6 +17,11 @@
 # include "ndds/ndds_cpp.h"
 #endif
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+# include "dds/DdsDcpsC.h"
+typedef ::DDS::Publisher DDSPublisher;
+#endif
+
 namespace CIAO
 {
   namespace DDS4CCM
diff --git a/CIAO/connectors/dds4ccm/impl/ConditionManager_T.cpp b/CIAO/connectors/dds4ccm/impl/ConditionManager_T.cpp
index a7b7aeb2262..773deed27db 100644
--- a/CIAO/connectors/dds4ccm/impl/ConditionManager_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/ConditionManager_T.cpp
@@ -1,7 +1,7 @@
 // $Id$
-#include "dds4ccm/impl/ndds/DataReader_T.h"
-#include "dds4ccm/impl/ndds/ReadCondition_T.h"
-#include "dds4ccm/impl/ndds/QueryCondition_T.h"
+#include "dds4ccm/impl/DataReader_T.h"
+#include "dds4ccm/impl/ReadCondition_T.h"
+#include "dds4ccm/impl/QueryCondition_T.h"
 
 #include "ace/OS_NS_sys_time.h"
 
@@ -475,14 +475,14 @@ CIAO::DDS4CCM::ConditionManager_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (
 }
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE> *
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *
 CIAO::DDS4CCM::ConditionManager_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl ()
 {
   return this->impl_;
 }
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE> *
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *
 CIAO::DDS4CCM::ConditionManager_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
 {
   if (this->impl_)
diff --git a/CIAO/connectors/dds4ccm/impl/ConditionManager_T.h b/CIAO/connectors/dds4ccm/impl/ConditionManager_T.h
index c50058521ac..60e8c02aec1 100644
--- a/CIAO/connectors/dds4ccm/impl/ConditionManager_T.h
+++ b/CIAO/connectors/dds4ccm/impl/ConditionManager_T.h
@@ -6,11 +6,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ReadCondition_T;
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_QueryCondition_T;
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_ReadCondition_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_QueryCondition_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
     //============================================================
@@ -19,11 +19,11 @@ namespace CIAO
     template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class ConditionManager_T
     {
-    typedef DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>
+    typedef CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       ReadCondition_type;
-    typedef DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>
+    typedef CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       QueryCondition_type;
-    typedef DataReader_T<DDS_TYPE, VENDOR_TYPE>
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       DataReader_type;
 
     public:
diff --git a/CIAO/connectors/dds4ccm/impl/ContentFilterSetting.h b/CIAO/connectors/dds4ccm/impl/ContentFilterSetting.h
index 9d5a8350a7a..ba7de8101d6 100644
--- a/CIAO/connectors/dds4ccm/impl/ContentFilterSetting.h
+++ b/CIAO/connectors/dds4ccm/impl/ContentFilterSetting.h
@@ -11,7 +11,7 @@
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 #include "dds4ccm/idl/dds4ccm_BaseEC.h"
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.h"
+#include "dds4ccm/impl/ContentFilteredTopic_T.h"
 
 #include "tao/LocalObject.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp
new file mode 100644
index 00000000000..e6d80030813
--- /dev/null
+++ b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.cpp
@@ -0,0 +1,124 @@
+// $Id$
+
+#include "ContentFilteredTopic_T.h"
+#include "Topic_T.h"
+
+#include "ndds/StringSeq.h"
+
+#include "dds4ccm/impl/Log_Macros.h"
+#include "dds4ccm/impl/dds4ccm_conf.h"
+
+namespace CIAO
+{
+  namespace DDS4CCM
+  {
+    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, 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, DDS4CCM_Vendor VENDOR_TYPE>
+    char *
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_filter_expression (void)
+    {
+      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, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::ReturnCode_t
+    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, VENDOR_TYPE>::get_expression_parameters");
+      DDS_StringSeq parameters;
+      ::DDS::ReturnCode_t retval =
+        this->impl ()->get_expression_parameters (parameters);
+      expression_parameters <<= parameters;
+      return retval;
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::ReturnCode_t
+    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, VENDOR_TYPE>::set_expression_parameters");
+
+      DDS_StringSeq parameters;
+      parameters <<= expression_parameters;
+      return this->impl ()->set_expression_parameters (parameters);
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::Topic_ptr
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_related_topic (void)
+    {
+      DDS4CCM_TRACE ("CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_related_topic");
+
+      ::DDS::Topic_var retval;
+      DDSTopic *topic = this->impl ()->get_related_topic ();
+      ACE_NEW_THROW_EX (retval,
+                        Topic_type (topic),
+                        ::CORBA::NO_MEMORY ());
+      return retval._retn ();
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    char *
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
+    {
+      return CORBA::string_dup (this->impl ()->get_type_name ());
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    char *
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
+    {
+      return CORBA::string_dup (this->impl ()->get_name ());
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::DomainParticipant_ptr
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
+    {
+      ::DDS::DomainParticipant_var retval;
+      DDSDomainParticipant * p = this->impl ()->get_participant ();
+      ACE_NEW_THROW_EX (retval,
+                        DomainParticipant_type (p),
+                        ::CORBA::NO_MEMORY ());
+      return retval._retn ();
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    DDSContentFilteredTopic *
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
+    {
+      return this->impl_;
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    void
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSContentFilteredTopic * dw)
+    {
+      this->impl_ = dw;
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    DDSContentFilteredTopic *
+    CCM_DDS_ContentFilteredTopic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
+    {
+      if (!this->impl_)
+        {
+          throw ::CORBA::BAD_INV_ORDER ();
+        }
+      return this->impl_;
+    }
+  }
+}
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/ContentFilteredTopic_T.h b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h
index b9c05c19b44..7e17febfbf1 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/ContentFilteredTopic_T.h
+++ b/CIAO/connectors/dds4ccm/impl/ContentFilteredTopic_T.h
@@ -11,29 +11,31 @@
 
 #include "DomainParticipant_T.h"
 
-#include "ndds/ndds_cpp.h"
-
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "ace/Copy_Disabled.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ContentFilteredTopic DDSContentFilteredTopic;
+#endif
+
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ContentFilteredTopic_T :
-      public virtual ::DDS::ContentFilteredTopic,
+    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,
       private ACE_Copy_Disabled
     {
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_TYPE> Topic_type;
-    typedef DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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
-      explicit DDS_ContentFilteredTopic_T (DDSContentFilteredTopic * dw = 0);
+      explicit CCM_DDS_ContentFilteredTopic_T (DDSContentFilteredTopic * dw = 0);
 
       /// Destructor
-      virtual ~DDS_ContentFilteredTopic_T (void);
+      virtual ~CCM_DDS_ContentFilteredTopic_T (void);
 
       virtual char * get_filter_expression (void);
 
@@ -63,6 +65,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.cpp"
+#include "dds4ccm/impl/ContentFilteredTopic_T.cpp"
 
 #endif /* CONTENFILTEREDTOPIC_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
index 17295120dff..688a011a7a3 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.cpp
@@ -1,14 +1,14 @@
 // $Id$
 
 #include "DDSDataReaderListener_T.h"
-#include "dds4ccm/impl/ndds/DataReader_T.h"
+#include "DataReader_T.h"
 
-#include "dds4ccm/impl/ndds/convertors/SampleLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h"
+#include "ndds/SampleLostStatus.h"
+#include "ndds/SubscriptionMatchedStatus.h"
+#include "ndds/RequestedDeadlineMissedStatus.h"
+#include "ndds/SampleRejectedStatus.h"
+#include "ndds/LivelinessChangedStatus.h"
+#include "ndds/RequestedIncompatibleQosStatus.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -18,8 +18,8 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReaderListener_ptr
-    CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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 2141cd5c245..6d0c079b165 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataReaderListener_T.h
@@ -33,11 +33,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_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, VENDOR_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 b4015cab8f3..b8954726efe 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.cpp
@@ -1,11 +1,11 @@
 // $Id$
 
-#include "dds4ccm/impl/DataWriterListener_T.h"
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
-#include "dds4ccm/impl/ndds/convertors/PublicationMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedIncompatibleQosStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedDeadlineMissedStatus.h"
+#include "DataWriterListener_T.h"
+#include "DataWriter_T.h"
+#include "ndds/PublicationMatchedStatus.h"
+#include "ndds/LivelinessLostStatus.h"
+#include "ndds/OfferedIncompatibleQosStatus.h"
+#include "ndds/OfferedDeadlineMissedStatus.h"
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 #include "dds4ccm/impl/Log_Macros.h"
@@ -14,8 +14,8 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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,18 +23,18 @@ namespace CIAO
     {
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_offered_deadline_missed");
+      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 (
@@ -42,13 +42,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_offered_incompatible_qos");
+      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 (
@@ -56,13 +56,13 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_liveliness_lost");
+      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 (
@@ -70,21 +70,21 @@ namespace CIAO
         ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_publication_matched");
+      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);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriterListener_ptr
-    CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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 1ab7617d50b..ca6a5bb3581 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSDataWriterListener_T.h
@@ -15,18 +15,28 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
+# include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DataWriterListener DDSDataWriterListener;
+typedef ::DDS::DataWriter DDSDataWriter;
+typedef ::DDS::OfferedDeadlineMissedStatus DDS_OfferedDeadlineMissedStatus;
+typedef ::DDS::OfferedIncompatibleQosStatus DDS_OfferedIncompatibleQosStatus;
+typedef ::DDS::LivelinessLostStatus DDS_LivelinessLostStatus;
+typedef ::DDS::PublicationMatchedStatus DDS_PublicationMatchedStatus;
+#endif
+
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DataWriter_T;
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T :
       public virtual ::DDSDataWriterListener
     {
-    typedef DDS_DataWriter_T<DDS_TYPE, VENDOR_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 345e309785f..35061aa3f69 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.cpp
@@ -1,15 +1,15 @@
 // $Id$
 
-#include "dds4ccm/impl/DDSPublisherListener_T.h"
-#include "dds4ccm/impl/ndds/Publisher_T.h"
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "DDSPublisherListener_T.h"
+#include "Publisher_T.h"
+#include "DataWriter_T.h"
 
-#include "dds4ccm/impl/ndds/convertors/PublicationMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedIncompatibleQosStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/ReliableReaderActivityChangedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/ReliableWriterCacheChangedStatus.h"
+#include "ndds/PublicationMatchedStatus.h"
+#include "ndds/LivelinessLostStatus.h"
+#include "ndds/OfferedIncompatibleQosStatus.h"
+#include "ndds/OfferedDeadlineMissedStatus.h"
+#include "ndds/ReliableReaderActivityChangedStatus.h"
+#include "ndds/ReliableWriterCacheChangedStatus.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -19,117 +19,117 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::DataWriter_ptr
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_TYPE>::get_datawriter_proxy (::DDSDataWriter * the_writer)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::CCM_DataWriter_ptr
+    CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datawriter_proxy (::DDSDataWriter * the_writer)
     {
-      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_TYPE>::get_datawriter_proxy");
-      ::DDS::DataWriter_var dds_writer;
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datawriter_proxy");
+      ::DDS::CCM_DataWriter_var dds_writer;
       ACE_NEW_NORETURN (dds_writer,
                         DataWriter_type (the_writer));
       return dds_writer._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_offered_deadline_missed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_deadline_missed");
 
       ::DDS::OfferedDeadlineMissedStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_offered_deadline_missed (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_offered_incompatible_qos");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_offered_incompatible_qos");
 
       ::DDS::OfferedIncompatibleQosStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_offered_incompatible_qos (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_liveliness_lost");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_lost");
 
       ::DDS::LivelinessLostStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_liveliness_lost (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_publication_matched");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_publication_matched");
 
       ::DDS::PublicationMatchedStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_publication_matched (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_reliable_reader_activity_changed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_reader_activity_changed");
 
       ::DDS::ReliableReaderActivityChangedStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_reliable_reader_activity_changed (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_reliable_writer_cache_changed");
+      DDS4CCM_TRACE ("CCM_DDS_PublisherListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_reliable_writer_cache_changed");
 
       ::DDS::ReliableWriterCacheChangedStatus ddsstatus;
-      ::DDS::DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
+      ::DDS::CCM_DataWriter_var proxy = this->get_datawriter_proxy (the_writer);
       ddsstatus <<= status;
       this->impl_->on_reliable_writer_cache_changed (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::PublisherListener_ptr
-    CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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 58c623a43bd..37642fbb3cb 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSPublisherListener_T.h
@@ -33,14 +33,14 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DataWriter_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DataWriter_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T :
       public virtual ::DDSPublisherListener
     {
-    typedef DDS_DataWriter_T<DDS_TYPE, VENDOR_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);
@@ -84,7 +84,7 @@ namespace CIAO
     private:
       ::DDS::PublisherListener_var impl_;
 
-      ::DDS::DataWriter_ptr
+      ::DDS::CCM_DataWriter_ptr
       get_datawriter_proxy (::DDSDataWriter * the_writer);
     };
   }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
index ccbfe72046e..d3fa15605a4 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.cpp
@@ -1,14 +1,14 @@
 // $Id$
 
-#include "dds4ccm/impl/DDSSubscriberListener_T.h"
-#include "dds4ccm/impl/ndds/Subscriber_T.h"
+#include "DDSSubscriberListener_T.h"
+#include "Subscriber_T.h"
 
-#include "dds4ccm/impl/ndds/convertors/SampleLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h"
+#include "ndds/SampleLostStatus.h"
+#include "ndds/SubscriptionMatchedStatus.h"
+#include "ndds/RequestedDeadlineMissedStatus.h"
+#include "ndds/SampleRejectedStatus.h"
+#include "ndds/LivelinessChangedStatus.h"
+#include "ndds/RequestedIncompatibleQosStatus.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
@@ -16,25 +16,25 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_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;
       ACE_NEW (sub,
@@ -43,116 +43,116 @@ namespace CIAO
       the_subscriber->notify_datareaders ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::DataReader_ptr
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_TYPE>::get_datareader_proxy (
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::CCM_DataReader_ptr
+    CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader_proxy (
       ::DDSDataReader * the_reader)
     {
-      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_TYPE>::get_datareader_proxy");
-      ::DDS::DataReader_var dds_reader;
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader_proxy");
+      ::DDS::CCM_DataReader_var dds_reader;
       ACE_NEW_NORETURN (dds_reader,
                         DataReader_type (the_reader));
       return dds_reader._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_requested_deadline_missed");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_deadline_missed");
 
       ::DDS::RequestedDeadlineMissedStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_requested_deadline_missed (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_requested_incompatible_qos");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_requested_incompatible_qos");
 
       ::DDS::RequestedIncompatibleQosStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_requested_incompatible_qos (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_sample_rejected");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_rejected");
 
       ::DDS::SampleRejectedStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_sample_rejected (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_liveliness_changed");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_liveliness_changed");
 
       ::DDS::LivelinessChangedStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_liveliness_changed (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_data_available");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_available");
 
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       this->impl_->on_data_available (proxy.in ());
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_subscription_matched");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_subscription_matched");
 
       ::DDS::SubscriptionMatchedStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_subscription_matched (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::on_sample_lost");
+      DDS4CCM_TRACE ("CCM_DDS_SubscriberListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_sample_lost");
 
       ::DDS::SampleLostStatus ddsstatus;
-      ::DDS::DataReader_var proxy = this->get_datareader_proxy (the_reader);
+      ::DDS::CCM_DataReader_var proxy = this->get_datareader_proxy (the_reader);
       ddsstatus <<= status;
       this->impl_->on_sample_lost (proxy.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SubscriberListener_ptr
-    CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_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 fdccfee6130..138617b4229 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSSubscriberListener_T.h
@@ -23,18 +23,15 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Subscriber_T;
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T :
       public virtual ::DDSSubscriberListener
     {
-    typedef DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE> Subscriber_type;
-    typedef DataReader_T<DDS_TYPE, VENDOR_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);
@@ -84,7 +81,7 @@ namespace CIAO
     private:
       ::DDS::SubscriberListener_var impl_;
 
-      ::DDS::DataReader_ptr
+    ::DDS::CCM_DataReader_ptr
       get_datareader_proxy (::DDSDataReader * the_reader);
     };
   }
diff --git a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
index fb8207a0f6c..d38aca4e746 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.cpp
@@ -1,9 +1,9 @@
 // $Id$
 
-#include "dds4ccm/impl/DDSTopicListener_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
+#include "DDSTopicListener_T.h"
+#include "Topic_T.h"
 
-#include "dds4ccm/impl/ndds/convertors/InconsistentTopicStatus.h"
+#include "ndds/InconsistentTopicStatus.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -13,25 +13,25 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
-    CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_TYPE>::on_inconsistent_topic (
+    CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_inconsistent_topic (
       ::DDSTopic* the_topic,
       const ::DDS_InconsistentTopicStatus & status)
     {
-      DDS4CCM_TRACE ("CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_TYPE>::on_inconsistent_topic");
+      DDS4CCM_TRACE ("CCM_DDS_TopicListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_inconsistent_topic");
 
       ::DDS::Topic_var dds_topic;
       ACE_NEW (dds_topic,
@@ -41,9 +41,9 @@ namespace CIAO
       this->impl_->on_inconsistent_topic (dds_topic.in (), ddsstatus);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicListener_ptr
-    CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_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 6ba6d05a109..f3eaded746b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDSTopicListener_T.h
@@ -22,11 +22,11 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_TopicListener_T :
       public virtual ::DDSTopicListener
     {
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_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 5294e910746..392e3160a6e 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.cpp
@@ -1,7 +1,7 @@
 // -*- C++ -*-
 // $Id$
 
-#include "dds4ccm/impl/ndds/DomainParticipant_T.h"
+#include "dds4ccm/impl/DomainParticipant_T.h"
 #include "ace/Tokenizer_T.h"
 #include "ace/Env_Value_T.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
index 4a91b2ea081..e8f38e49ec7 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Base_Connector_T.h
@@ -9,7 +9,7 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "ace/Copy_Disabled.h"
 #include "dds4ccm/impl/DomainParticipantListener_T.h"
-#include "dds4ccm/impl/ndds/DomainParticipantFactory_T.h"
+#include "dds4ccm/impl/DomainParticipantFactory_T.h"
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_Base_Connector_T
@@ -19,7 +19,7 @@ class DDS_Base_Connector_T
 {
 typedef ::CIAO::DDS4CCM::DomainParticipantListener_T<DDS_TYPE, VENDOR_TYPE>
   DomainParticipantListener;
-typedef ::CIAO::DDS4CCM::DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>
+typedef ::CIAO::DDS4CCM::CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
   DomainParticipantFactory;
 
 public:
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
index 6a128c4e40b..4bf2cb8068f 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_State_Connector_T.cpp
@@ -6,7 +6,7 @@
 #include "dds4ccm/impl/Updater_T.h"
 #include "dds4ccm/impl/Reader_T.h"
 #include "dds4ccm/impl/PublisherListener_T.h"
-#include "dds4ccm/impl/ndds/SubscriberListener_T.h"
+#include "dds4ccm/impl/SubscriberListener_T.h"
 #include "dds4ccm/impl/DataListenerControl_T.h"
 #include "dds4ccm/impl/StateListenerControl_T.h"
 #include "dds4ccm/impl/PortStatusListener_T.h"
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
index dc2e09256ba..c5cfb8a3856 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.cpp
@@ -159,9 +159,8 @@ template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDO
 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, VENDOR_TYPE>::get_dds_entity");
-  throw CORBA::NO_IMPLEMENT ();
-//   return ::DDS::DataReader::_nil ();
-//   return ::DDS::DataReader::_duplicate (this->data_reader_);
+
+  return ::DDS::CCM_DataReader::_duplicate (this->data_reader_);
 }
 
 template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
index e7af8ec0c83..434822cf640 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Subscriber_Base_T.h
@@ -11,10 +11,10 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 #include "dds4ccm/impl/Reader_T.h"
-#include "dds4ccm/impl/ndds/DataReader_T.h"
+#include "dds4ccm/impl/DataReader_T.h"
 #include "dds4ccm/impl/PortStatusListener_T.h"
 #include "dds4ccm/impl/ContentFilterSetting.h"
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.h"
+#include "dds4ccm/impl/ContentFilteredTopic_T.h"
 #include "dds4ccm/impl/ConditionManager_T.h"
 
 template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
@@ -64,7 +64,7 @@ protected:
     PortStatusListener_type;
   typedef ::CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>
     Reader_type;
-  typedef ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>
+  typedef ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     DataReader_type;
   typedef ::CIAO::DDS4CCM::CCM_DDS_ContentFilterSetting_i
     ContentFilterSetting_type;
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
index c3987e68b42..8559ae5fdfd 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.cpp
@@ -183,8 +183,8 @@ DDS_TopicBase_Connector_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::init_default_topic (
 
   if (::CORBA::is_nil (this->topic_.in ()))
     {
-      ::CIAO::DDS4CCM::DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE> *part =
-        dynamic_cast< CIAO::DDS4CCM::DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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 ());
       if (!part)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
index 6012303d6e2..dec4a2a239b 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_TopicBase_Connector_T.h
@@ -10,10 +10,10 @@
 
 #include "ace/Copy_Disabled.h"
 #include "dds4ccm/impl/DDS_Base_Connector_T.h"
-#include "dds4ccm/impl/ndds/DomainParticipant_T.h"
+#include "dds4ccm/impl/DomainParticipant_T.h"
 #include "dds4ccm/impl/DDSTopicListener_T.h"
 #include "dds4ccm/impl/PublisherListener_T.h"
-#include "dds4ccm/impl/ndds/SubscriberListener_T.h"
+#include "dds4ccm/impl/SubscriberListener_T.h"
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 class DDS_TopicBase_Connector_T
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
index fa148e33c4b..a1fc83077a0 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.cpp
@@ -4,7 +4,7 @@
 #include "dds4ccm/impl/DataReaderStateListener_T.h"
 #include "dds4ccm/impl/DataWriterListener_T.h"
 #include "dds4ccm/impl/Updater_T.h"
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "dds4ccm/impl/DataWriter_T.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
@@ -141,7 +141,6 @@ DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove (
   ::DDS::Publisher_ptr publisher)
 {
   DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::remove");
-
   ::DDS::ReturnCode_t const retval =
     publisher->delete_datawriter (this->ccm_dds_writer_);
   if (retval != ::DDS::RETCODE_OK)
@@ -161,8 +160,6 @@ 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, VENDOR_TYPE>::get_data (void)
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_data");
-
   return CCM_TYPE::updater_type::_duplicate (this->dds_update_);
 }
 
@@ -170,10 +167,6 @@ template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::CCM_DataWriter_ptr
 DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity (void)
 {
-  DDS4CCM_TRACE ("DDS_Update_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity");
-
-  CORBA::NO_IMPLEMENT ();
-  return ::DDS::CCM_DataWriter::_nil ();
-//   return ::DDS::CCM_DataWriter::_duplicate (this->ccm_dds_writer_);
+  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 66cde3cb196..f2ee6dcecb2 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Update_T.h
@@ -39,7 +39,7 @@ public:
 private:
   typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     DataWriterListener_type;
-  typedef ::CIAO::DDS4CCM::DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>
+  typedef ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     DataWriter_type;
   typedef ::CIAO::DDS4CCM::Updater_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     Updater_type;
diff --git a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
index 1f16d51cb9b..c73c97ca595 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.cpp
@@ -169,8 +169,7 @@ template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity (void)
 {
   DDS4CCM_TRACE ("DDS_Write_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_dds_entity");
-  throw CORBA::NO_IMPLEMENT ();
-  ::DDS::CCM_DataWriter::_nil ();
-//   return ::DDS::CCM_DataWriter::_duplicate (this->ccm_dds_writer_);
+
+  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 3a8b2472021..9a9a7430cb1 100644
--- a/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DDS_Write_T.h
@@ -48,7 +48,7 @@ private:
   typedef ::CIAO::DDS4CCM::Writer_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Writer_type;
   typedef ::CIAO::DDS4CCM::DataWriterListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     DataWriterListener_type;
-  typedef ::CIAO::DDS4CCM::DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>
+  typedef ::CIAO::DDS4CCM::CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
     DataWriter_type;
 
   /**
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataReader.cpp b/CIAO/connectors/dds4ccm/impl/DataReader.cpp
index 71359078b83..3362c8822e5 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataReader.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReader.cpp
@@ -6,7 +6,7 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    DDS_DataReader_Base::~DDS_DataReader_Base (void)
+    CCM_DDS_DataReader_Base::~CCM_DDS_DataReader_Base (void)
     {
     }
   }
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataReader.h b/CIAO/connectors/dds4ccm/impl/DataReader.h
index e00f1025e91..c475ee539ef 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataReader.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReader.h
@@ -12,23 +12,25 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/idl/dds_rtf2_dcpsEC.h"
 
-#include "dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h"
+#include "dds4ccm/impl/dds4ccm_dds_impl_export.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
 #include "tao/LocalObject.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    class DDS4CCM_DDS_NDDS_Export DDS_DataReader_Base
-      : public virtual ::DDS::DataReader,
+    class DDS4CCM_DDS_IMPL_Export CCM_DDS_DataReader_Base
+      : public virtual ::DDS::CCM_DataReader,
         public virtual ::CORBA::LocalObject
     {
     public:
-      virtual ~DDS_DataReader_Base (void);
+      virtual ~CCM_DDS_DataReader_Base (void);
 
       virtual DDSDataReader * get_impl (void) = 0;
     };
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
index faf4ca682c9..0c03ddefc9c 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderListener_T.cpp
@@ -68,8 +68,8 @@ CIAO::DDS4CCM::DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_data_av
       return;
     }
 
-  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE> * reader =
-    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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)
     {
diff --git a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
index de4b40d6a7b..6e5489598d1 100644
--- a/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReaderStateListener_T.cpp
@@ -70,8 +70,8 @@ CIAO::DDS4CCM::DataReaderStateListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::on_da
       return;
     }
 
-  ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE> * reader =
-    dynamic_cast < ::CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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)
     {
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataReader_T.cpp b/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp
index 10fbf9aba20..f94b59bb360 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataReader_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataReader_T.cpp
@@ -1,32 +1,32 @@
 // $Id$
 
-#include "dds4ccm/impl/DDSDataReaderListener_T.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/ndds/ReadCondition_T.h"
-#include "dds4ccm/impl/ndds/QueryCondition_T.h"
-#include "dds4ccm/impl/ndds/Subscriber_T.h"
-#include "dds4ccm/impl/ndds/TopicDescription_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.h"
-
-#include "dds4ccm/impl/ndds/convertors/SampleLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/PublicationBuiltinTopicData.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h"
-#include "dds4ccm/impl/ndds/convertors/Duration_t.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandleSeq.h"
-#include "dds4ccm/impl/ndds/convertors/DataReaderQos.h"
-#include "dds4ccm/impl/ndds/convertors/StringSeq.h"
+#include "DDSDataReaderListener_T.h"
+#include "StatusCondition.h"
+#include "ReadCondition_T.h"
+#include "QueryCondition_T.h"
+#include "Subscriber_T.h"
+#include "TopicDescription_T.h"
+#include "Topic_T.h"
+#include "ContentFilteredTopic_T.h"
+
+#include "ndds/SampleLostStatus.h"
+#include "ndds/SubscriptionMatchedStatus.h"
+#include "ndds/RequestedDeadlineMissedStatus.h"
+#include "ndds/SampleRejectedStatus.h"
+#include "ndds/LivelinessChangedStatus.h"
+#include "ndds/PublicationBuiltinTopicData.h"
+#include "ndds/RequestedIncompatibleQosStatus.h"
+#include "ndds/Duration_t.h"
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/InstanceHandleSeq.h"
+#include "ndds/DataReaderQos.h"
+#include "ndds/StringSeq.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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),
     lst_mask_ (0)
 {
@@ -37,15 +37,15 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::DataReader_T (DDSDataReader
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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");
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::log_query_condition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::log_query_condition (
   DDSQueryCondition * qc)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::log_query_condition");
@@ -80,9 +80,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::log_query_condition (
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::read_wo_instance (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::read_wo_instance (
   typename DDS_TYPE::dds_seq_type & data,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info,
   DDSQueryCondition * qc)
@@ -124,9 +124,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::read_wo_instance (
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info)
@@ -162,9 +162,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::read_w_instance (
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get (
   typename DDS_TYPE::dds_seq_type & data,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info,
   const DDS_Long & max_samples,
@@ -183,9 +183,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get (
   return DDS_RETCODE_ERROR;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get (
   typename DDS_TYPE::dds_seq_type & data,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info,
   const DDS_Long & max_samples,
@@ -203,9 +203,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get (
    return DDS_RETCODE_ERROR;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::take (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::take (
   typename DDS_TYPE::dds_seq_type & data,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info,
   const DDS_Long & max_samples,
@@ -232,17 +232,17 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::take (
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS_InstanceHandle_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS_ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::return_loan (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::return_loan (
   typename DDS_TYPE::dds_seq_type & data,
   typename DDS_TYPE::sampleinfo_seq_type & sample_info)
 {
@@ -251,9 +251,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::return_loan (
   return this->impl ()->return_loan (data, sample_info);
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::passivate ()
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::passivate ()
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::passivate");
 
@@ -270,9 +270,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::passivate ()
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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,
@@ -303,9 +303,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::create_datareader (
   this->set_impl(reader.in ());
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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,
@@ -337,9 +337,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::create_datareader (
   this->set_impl (reader.in ());
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::delete_datareader (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datareader (
   ::DDS::Subscriber_ptr subscriber)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::delete_datareader");
@@ -356,9 +356,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::delete_datareader (
   this->impl_ = 0;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 typename DDS_TYPE::datareader_type *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
 {
   if (this->impl_)
     {
@@ -370,16 +370,16 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
 {
   return this->impl ()->enable ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_statuscondition");
 
@@ -388,24 +388,24 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
   if (sc)
     {
       ACE_NEW_THROW_EX (retval,
-                        DDS_StatusCondition_i (sc),
+                        CCM_DDS_StatusCondition_i (sc),
                         ::CORBA::NO_MEMORY ());
     }
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_status_changes (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_status_changes (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_status_changes");
 
   return this->impl ()->get_status_changes ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDS_INSTANCE_HANDLE_T_RETN
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_instance_handle");
 
@@ -416,9 +416,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
   return handle;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReadCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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)
@@ -439,9 +439,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::create_readcondition (
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::QueryCondition_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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,
@@ -469,9 +469,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::create_querycondition (
   return retval._retn ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::delete_readcondition (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_readcondition (
   ::DDS::ReadCondition_ptr a_condition)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::delete_readcondition");
@@ -519,18 +519,18 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::delete_readcondition (
   return retcode;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contained_entities (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::delete_contained_entities");
 
   return this->impl ()->delete_contained_entities ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::set_qos (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
   const ::DDS::DataReaderQos &qos)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::set_qos");
@@ -540,9 +540,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::set_qos (
   return this->impl ()->set_qos (ddsqos);
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_qos (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
   ::DDS::DataReaderQos &qos)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_qos");
@@ -553,13 +553,13 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_qos (
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::set_listener");
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
   // Delete the previously set listener
   DDSDataReaderListener *listener = this->impl ()->get_listener ();
@@ -578,15 +578,15 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::set_listener (
   return this->impl ()->set_listener (ccm_dds_drl, mask);
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::DataReaderListener_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::get_listener");
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
   DDSDataReaderListener *drl = this->impl ()->get_listener ();
-  CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_TYPE> *ccm_dds_drl =
-    dynamic_cast <CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_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 (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, "DataReader_T"
@@ -597,9 +597,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
   return ccm_dds_drl->get_datareaderlistener ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::TopicDescription_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_topicdescription (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_topicdescription (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_topicdescription");
 
@@ -631,9 +631,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_topicdescription (void)
   return dds_td._retn ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::Subscriber_ptr
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_subscriber (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_subscriber (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_subscriber");
 
@@ -645,9 +645,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_subscriber (void)
   return dds_td._retn ();
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_sample_rejected_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_rejected_status (
   ::DDS::SampleRejectedStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_sample_rejected_status");
@@ -658,9 +658,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_sample_rejected_status (
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_liveliness_changed_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_liveliness_changed_status (
   ::DDS::LivelinessChangedStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_liveliness_changed_status");
@@ -671,9 +671,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_liveliness_changed_statu
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_requested_deadline_missed_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_requested_deadline_missed_status (
   ::DDS::RequestedDeadlineMissedStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_requested_deadline_missed_status");
@@ -684,9 +684,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_requested_deadline_misse
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_requested_incompatible_qos_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_requested_incompatible_qos_status (
   ::DDS::RequestedIncompatibleQosStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_requested_incompatible_qos_status");
@@ -698,9 +698,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_requested_incompatible_q
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_subscription_matched_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_subscription_matched_status (
   ::DDS::SubscriptionMatchedStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_subscription_matched_status");
@@ -711,9 +711,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_subscription_matched_sta
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_sample_lost_status (
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_lost_status (
   ::DDS::SampleLostStatus & status)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_sample_lost_status");
@@ -724,9 +724,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_sample_lost_status (
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::wait_for_historical_data");
@@ -736,12 +736,12 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::wait_for_historical_data (
   return this->impl ()->wait_for_historical_data (rtiduration);
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE>::get_matched_publications");
+  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);
@@ -749,9 +749,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_matched_publications (
   return retval;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::ReturnCode_t
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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)
 {
@@ -769,18 +769,18 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_matched_publication_data
   return retcode;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 ::DDS::StatusMask
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_mask (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_mask (void)
 {
   DDS4CCM_TRACE ("CIAO::DDS4CCM::DataReader_T::get_mask");
 
   return this->lst_mask_;
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 void
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_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");
@@ -805,9 +805,9 @@ CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::set_impl (
     }
 }
 
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
 DDSDataReader *
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
+CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
 {
   return this->impl_;
 }
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataReader_T.h b/CIAO/connectors/dds4ccm/impl/DataReader_T.h
index a740ae3dcac..4d78f0e5a87 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataReader_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataReader_T.h
@@ -13,44 +13,41 @@
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
 #include "dds4ccm/impl/Utils.h"
-#include "dds4ccm/impl/ndds/DataReader.h"
+#include "dds4ccm/impl/DataReader.h"
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::InstanceHandle_t DDS_InstanceHandle_t;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T;
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Subscriber_T;
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ReadCondition_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_ReadCondition_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_QueryCondition_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_QueryCondition_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ContentFilteredTopic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataReaderListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DataReader_T
-      : public virtual DDS_DataReader_Base
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class DataReader_T : public virtual CCM_DDS_DataReader_Base
     {
-    typedef ::CIAO::DDS4CCM::CCM_DDS_DataReaderListener_T<DDS_TYPE, VENDOR_TYPE>
+    typedef ::CIAO::DDS4CCM::CCM_DDS_DataReaderListener_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
       DataReaderListener_type;
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_TYPE> Topic_type;
-    typedef DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE> ReadCondition_type;
-    typedef DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE> QueryCondition_type;
-    typedef DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE> ContentFilteredTopic_type;
-    typedef DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE> Subscriber_type;
-    typedef DataReader_T<DDS_TYPE, VENDOR_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
       explicit DataReader_T (DDSDataReader * dr = 0);
@@ -106,9 +103,9 @@ namespace CIAO
 
       void
       create_datareader (::DDS::Topic_ptr topic,
-                         ::DDS::Subscriber_ptr subscriber,
-                         const char * library_name,
-                         const char * profile_name);
+                          ::DDS::Subscriber_ptr subscriber,
+                          const char * library_name,
+                          const char * profile_name);
 
       virtual ::DDS::ReturnCode_t enable (void);
 
@@ -205,6 +202,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/DataReader_T.cpp"
+#include "dds4ccm/impl/DataReader_T.cpp"
 
 #endif /* DATAREADER_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter.cpp b/CIAO/connectors/dds4ccm/impl/DataWriter.cpp
index dc61a8ebceb..dc61a8ebceb 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter.cpp
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter.h b/CIAO/connectors/dds4ccm/impl/DataWriter.h
index 62e1f893512..c352ed1206b 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter.h
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter.h
@@ -12,19 +12,25 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/idl/dds_rtf2_dcpsEC.h"
 
-#include "dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h"
+#include "dds4ccm/impl/dds4ccm_dds_impl_export.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
 #include "tao/LocalObject.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DataWriter DDSDataWriter;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    class DDS4CCM_DDS_NDDS_Export CCM_DDS_DataWriter_Base
-      : public virtual ::DDS::DataWriter,
+    class DDS4CCM_DDS_IMPL_Export CCM_DDS_DataWriter_Base
+      : public virtual ::DDS::CCM_DataWriter,
         public virtual ::CORBA::LocalObject
     {
     public:
@@ -44,4 +50,4 @@ namespace CIAO
   }
 }
 
-#endif /* DDS4CCM_DATAWRITER_H */
\ No newline at end of file
+#endif
diff --git a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
index 953d05dae16..ae4be0009ff 100644
--- a/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataWriterListener_T.cpp
@@ -1,7 +1,7 @@
 // $Id$
 #include "dds4ccm/impl/Utils.h"
 
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "dds4ccm/impl/DataWriter_T.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter_T.cpp b/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp
index d9215efe9c5..4d7a7055644 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter_T.cpp
@@ -1,21 +1,20 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
-#include "dds4ccm/impl/ndds/DataWriter.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/ndds/Publisher_T.h"
-#include "dds4ccm/impl/DDSDataWriterListener_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
-
-#include "dds4ccm/impl/ndds/convertors/Duration_t.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
-#include "dds4ccm/impl/ndds/convertors/PublicationMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedIncompatibleQosStatus.h"
-#include "dds4ccm/impl/ndds/convertors/OfferedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandleSeq.h"
-#include "dds4ccm/impl/ndds/convertors/DataWriterQos.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriptionBuiltinTopicData.h"
+#include "DataWriter_T.h"
+#include "StatusCondition.h"
+#include "Publisher_T.h"
+#include "DDSDataWriterListener_T.h"
+#include "Topic_T.h"
+
+#include "ndds/Duration_t.h"
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/PublicationMatchedStatus.h"
+#include "ndds/LivelinessLostStatus.h"
+#include "ndds/OfferedIncompatibleQosStatus.h"
+#include "ndds/OfferedDeadlineMissedStatus.h"
+#include "ndds/InstanceHandleSeq.h"
+#include "ndds/DataWriterQos.h"
+#include "ndds/SubscriptionBuiltinTopicData.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
@@ -23,27 +22,27 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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 ("DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::set_qos");
+      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);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_qos (::DDS::DataWriterQos & qos)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::DataWriterQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_qos");
+      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);
@@ -51,9 +50,9 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::set_listener (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
       ::DDS::DataWriterListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
@@ -71,9 +70,9 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriterListener_ptr
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
       DDSDataWriterListener *wr = this->impl ()->get_listener ();
       DataWriterListener_type * list_proxy =
@@ -81,16 +80,16 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG,
-                        "DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_listener - "
+                        "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 ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_topic (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_topic (void)
     {
       ::DDS::Topic_var retval;
       DDSTopic* t = this->impl ()->get_topic ();
@@ -100,9 +99,9 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_publisher (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_publisher (void)
     {
       ::DDS::Publisher_var retval;
       DDSPublisher* p = this->impl ()->get_publisher ();
@@ -112,18 +111,18 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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)
     {
      ::DDS_Duration_t rtiduration;
      rtiduration <<= max_wait;
      return this->impl ()->wait_for_acknowledgments (rtiduration);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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)
     {
       ::DDS_LivelinessLostStatus ddsstatus;
       ddsstatus <<= status;
@@ -132,9 +131,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_offered_deadline_missed_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_offered_deadline_missed_status (
       ::DDS::OfferedDeadlineMissedStatus & status)
     {
       ::DDS_OfferedDeadlineMissedStatus ddsstatus;
@@ -145,9 +144,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_offered_incompatible_qos_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_offered_incompatible_qos_status (
       ::DDS::OfferedIncompatibleQosStatus & status)
     {
       ::DDS_OfferedIncompatibleQosStatus ddsstatus;
@@ -158,9 +157,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_publication_matched_status (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_publication_matched_status (
       ::DDS::PublicationMatchedStatus & status)
     {
       ::DDS_PublicationMatchedStatus ddsstatus;
@@ -171,16 +170,16 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_matched_subscriptions (
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_matched_subscriptions (
       ::DDS::InstanceHandleSeq & subscription_handles)
     {
       ::DDS_InstanceHandleSeq rtiseq;
@@ -190,13 +189,13 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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 ("DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_matched_subscription_data");
+      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;
@@ -206,35 +205,35 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval;
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       ACE_NEW_THROW_EX (retval,
-                        DDS_StatusCondition_i (sc),
+                        CCM_DDS_StatusCondition_i (sc),
                         ::CORBA::NO_MEMORY ());
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDS_INSTANCE_HANDLE_T_RETN
-    DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+    CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
       ::DDS_InstanceHandle_t const rtihandle =
         this->impl ()->get_instance_handle ();
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter_T.h b/CIAO/connectors/dds4ccm/impl/DataWriter_T.h
index 3e195a40db7..b42147234b0 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DataWriter_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DataWriter_T.h
@@ -13,35 +13,41 @@
 
 #include "dds4ccm/idl/dds_rtf2_dcpsEC.h"
 
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
-#include "dds4ccm/impl/ndds/DataWriter.h"
+#include "dds4ccm/impl/DataWriter.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DataWriter DDSDataWriter;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Publisher_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Publisher_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DataWriter_T
+    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, VENDOR_TYPE> DataWriterListener_type;
-    typedef DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE> Publisher_type;
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_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 DDS_DataWriter_T (DDSDataWriter * dw = 0);
+      explicit CCM_DDS_DataWriter_T (DDSDataWriter * dw = 0);
 
       virtual ::DDS::ReturnCode_t set_qos (const ::DDS::DataWriterQos & qos);
 
@@ -92,6 +98,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/DataWriter_T.cpp"
+#include "dds4ccm/impl/DataWriter_T.cpp"
 
 #endif /* DATAWRITER_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactory_T.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp
index 0ad7ff871da..5194ce359bf 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactory_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.cpp
@@ -1,51 +1,57 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/DomainParticipantFactory_T.h"
-#include "dds4ccm/impl/ndds/DomainParticipant_T.h"
+#include "DomainParticipantFactory_T.h"
+#include "DomainParticipant_T.h"
+#include "DomainParticipantListener.h"
 
-#include "dds4ccm/impl/DDSDomainParticipantListener.h"
+#include "ndds/DomainParticipantFactoryQos.h"
+#include "ndds/DomainParticipantQos.h"
 
-#include "dds4ccm/impl/ndds/convertors/DomainParticipantFactoryQos.h"
-#include "dds4ccm/impl/ndds/convertors/DomainParticipantQos.h"
-
-#include "dds4ccm/impl/Utils.h"
+#include "Utils.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-#include "dds4ccm/impl/DomainParticipantManager.h"
+#if (CIAO_DDS4CCM_NDDS==1)
+# include "DomainParticipantManager.h"
+#endif
+
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+  typedef  ::DDS::DomainParticipantFactory DDSDomainParticipantFactory;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::DDS_DomainParticipantFactory_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipantFactory_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::~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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::~DDS_DomainParticipantFactory_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipantFactory_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_participant - "
                     "Start creating domain participant for domain <%d>\n",
                     domain_id));
@@ -74,8 +80,8 @@ namespace CIAO
           if (!dds_dp)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                          "DDS_DomainParticipantFactory_T"
-                          "<DDS_TYPE, VENDOR_TYPE>::create_participant - "
+                          "CCM_DDS_DomainParticipantFactory_T"
+                          "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_participant - "
                           "Error: Unable to create DomainParticipant for domain <%d>\n",
                           domain_id));
               throw ::CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -94,7 +100,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_participant - Re-using participant "
                         "for QOS profile <%C> and domain <%d>.\n",
                         qos_profile.c_str (),
@@ -105,22 +111,30 @@ namespace CIAO
                             ::CORBA::NO_MEMORY ());
           return retval._retn ();
         }
+#else
+      return DDSDomainParticipantFactory::get_instance ()->
+        create_participant (domain_id,
+                            qos,
+                            a_listener,
+                            mask);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
                      "create_participant_with_profile");
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_participant_with_profile - "
                     "Start creating domain participant: "
                     "profile <%C#%C> - domain <%d>\n",
@@ -144,7 +158,7 @@ namespace CIAO
       if (!dds_dp)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_participant_with_profile - "
                         "Creating participant: profile <%C> - domain <%d>\n",
                         qos_profile.c_str (),
@@ -158,7 +172,7 @@ namespace CIAO
           if (!dds_dp)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                            "CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, "
                             "VENDOR_TYPE>::create_participant_with_profile - "
                             "Error: Unable to create DomainParticipant\n"));
               throw ::CCM_DDS::InternalError (::DDS::RETCODE_ERROR, 0);
@@ -181,7 +195,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipantFactory_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipantFactory_T<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 (),
@@ -193,31 +207,33 @@ namespace CIAO
           return retval._retn ();
         }
     }
+#endif
 
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::delete_participant (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant (
       ::DDS::DomainParticipant_ptr a_participant)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 =
         dynamic_cast< DomainParticipant_type * > (a_participant);
 
       if (!part)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipantFactory_T"
-                        "<DDS_TYPE, VENDOR_TYPE>::delete_participant - "
+                        "CCM_DDS_DomainParticipantFactory_T"
+                        "<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 (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipantFactory_T"
-                    "<DDS_TYPE, VENDOR_TYPE>::delete_participant - "
+                    "CCM_DDS_DomainParticipantFactory_T"
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                     "Successfully casted provided object reference to servant type.\n"));
 
       ::DDS::ReturnCode_t retval = DDS::RETCODE_OK;
@@ -225,8 +241,8 @@ namespace CIAO
       if (DPMANAGER->remove_participant (part->get_impl ()))
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipantFactory_T"
-                    "<DDS_TYPE, VENDOR_TYPE>::delete_participant - "
+                    "CCM_DDS_DomainParticipantFactory_T"
+                    "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                     "Going to delete participant.\n"));
 
           retval = DDSDomainParticipantFactory::get_instance ()->
@@ -235,99 +251,147 @@ namespace CIAO
           if (retval != DDS::RETCODE_OK)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_DomainParticipantFactory_T"
-                            "<DDS_TYPE, VENDOR_TYPE>::delete_participant - "
+                            "CCM_DDS_DomainParticipantFactory_T"
+                            "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                             "RTI delete_participant returned non-ok error code %C\n",
                             translate_retcode (retval)));
             }
           else
             {
               DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                             "DDS_DomainParticipantFactory_T"
-                             "<DDS_TYPE, VENDOR_TYPE>::delete_participant - "
+                             "CCM_DDS_DomainParticipantFactory_T"
+                             "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_participant - "
                              "Successfully deleted provided participant.\n"));
             }
         }
       return retval;
+#else
+      return DDSDomainParticipantFactory::get_instance ()->
+              delete_participant (a_participant);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::lookup_participant (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_participant (
       ::DDS::DomainId_t domain_id)
     {
       ::DDS::DomainParticipant_var retval;
+#if (CIAO_DDS4CCM_NDDS==1)
       ::DDSDomainParticipant* dp = DDSDomainParticipantFactory::get_instance ()
         ->lookup_participant (domain_id);
        ACE_NEW_THROW_EX (retval,
                          DomainParticipant_type (dp),
                          ::CORBA::NO_MEMORY ());
+#else
+      ::DDS::DomainParticipant_var dp =
+        DDSDomainParticipantFactory::get_instance ()->lookup_participant (domain_id);
+      ACE_NEW_THROW_EX (retval,
+                        DomainParticipant_type  (dp.in ()),
+                        ::CORBA::NO_MEMORY ());
+#endif
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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;
       ccm_dds_qos <<= qos;
       return DDSDomainParticipantFactory::get_instance ()->
         set_default_participant_qos (ccm_dds_qos);
+#else
+      return DDSDomainParticipantFactory::get_instance ()->
+        set_default_participant_qos (qos);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::get_default_participant_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_participant_qos (
       ::DDS::DomainParticipantQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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;
       ::DDS::ReturnCode_t retcode =
         DDSDomainParticipantFactory::get_instance ()->
           get_default_participant_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
+#else
+      return DDSDomainParticipantFactory::get_instance ()->
+        get_default_participant_qos (qos);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::set_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
       const ::DDS::DomainParticipantFactoryQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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;
       return DDSDomainParticipantFactory::get_instance ()->set_qos (ccm_dds_qos);
+#else
+      return DDSDomainParticipantFactory::get_instance ()->set_qos (qos);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::get_qos (
+    CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
       ::DDS::DomainParticipantFactoryQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 =
         DDSDomainParticipantFactory::get_instance ()->get_qos (ccm_dds_qos);
       ccm_dds_qos <<= qos;
       return retcode;
+#else
+      return DDSDomainParticipantFactory::get_instance ()->get_qos (qos);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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 ("DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_TYPE>::"
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipantFactory_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::"
                      "set_default_participant_qos_with_profile");
 
       return DDSDomainParticipantFactory::get_instance ()->
         set_default_participant_qos_with_profile (library_name, profile_name);
     }
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::DomainParticipantFactory_ptr
+    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, VENDOR_TYPE>,
+        ::CORBA::NO_MEMORY ());
+
+      return retval._retn ();
+    }
+#endif
   }
 }
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactory_T.h b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h
index 8333e60264a..9082447d066 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactory_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantFactory_T.h
@@ -21,25 +21,29 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipant_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipantFactory_T :
+    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 DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE> DomainParticipant_type;
-      typedef DDS_DomainParticipantFactory_T<DDS_TYPE, VENDOR_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
-      DDS_DomainParticipantFactory_T (void);
+      CCM_DDS_DomainParticipantFactory_T (void);
 
       /// Destructor
-      virtual ~DDS_DomainParticipantFactory_T (void);
+      virtual ~CCM_DDS_DomainParticipantFactory_T (void);
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+      virtual ::DDS::DomainParticipantFactory_ptr get_instance (void);
+#endif
 
       virtual ::DDS::DomainParticipant_ptr create_participant (
           ::DDS::DomainId_t domain_id,
@@ -47,12 +51,14 @@ namespace CIAO
           ::DDS::DomainParticipantListener_ptr a_listener,
           ::DDS::StatusMask mask);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::DomainParticipant_ptr 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);
+#endif
 
       virtual ::DDS::ReturnCode_t delete_participant (
         ::DDS::DomainParticipant_ptr a_participant);
@@ -72,13 +78,15 @@ namespace CIAO
       virtual
         ::DDS::ReturnCode_t get_qos (::DDS::DomainParticipantFactoryQos & qos);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::ReturnCode_t set_default_participant_qos_with_profile(
                                                         const char * library_name,
                                                         const char * profile_name);
+#endif
     };
   }
 }
 
-#include "dds4ccm/impl/ndds/DomainParticipantFactory_T.cpp"
+#include "dds4ccm/impl/DomainParticipantFactory_T.cpp"
 
 #endif /* DOMAINPARTICIPANTFACTORY_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDomainParticipantListener.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener.cpp
index 4c6b37d4101..ecb21b31e3f 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDomainParticipantListener.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener.cpp
@@ -1,17 +1,14 @@
 // $Id$
 
 #include "DomainParticipantListener_T.h"
-
-#if (CIAO_DDS4CCM_NDDS==1)
-#include "dds4ccm/impl/ndds/DomainParticipant_T.h"
-#endif
-
-#include "dds4ccm/impl/ndds/convertors/SampleLostStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h"
-#include "dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h"
+#include "DomainParticipant_T.h"
+
+#include "ndds/SampleLostStatus.h"
+#include "ndds/SubscriptionMatchedStatus.h"
+#include "ndds/RequestedDeadlineMissedStatus.h"
+#include "ndds/SampleRejectedStatus.h"
+#include "ndds/LivelinessChangedStatus.h"
+#include "ndds/RequestedIncompatibleQosStatus.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/DDSDomainParticipantListener.h b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener.h
index de145f826ea..de145f826ea 100644
--- a/CIAO/connectors/dds4ccm/impl/DDSDomainParticipantListener.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipantListener.h
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipant_T.cpp b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp
index 3e034eb215e..c73390f2a02 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipant_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.cpp
@@ -4,25 +4,25 @@
 #include "Publisher_T.h"
 #include "ContentFilteredTopic_T.h"
 #include "TopicDescription_T.h"
-#include "dds4ccm/impl/Utils.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/DDSPublisherListener_T.h"
-#include "dds4ccm/impl/DDSSubscriberListener_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
-#include "dds4ccm/impl/TopicListener_T.h"
-#include "dds4ccm/impl/DDSDomainParticipantListener.h"
-#include "dds4ccm/impl/DomainParticipantManager.h"
-
-#include "dds4ccm/impl/ndds/convertors/PublisherQos.h"
-#include "dds4ccm/impl/ndds/convertors/SubscriberQos.h"
-#include "dds4ccm/impl/ndds/convertors/TopicQos.h"
-#include "dds4ccm/impl/ndds/convertors/DomainParticipantQos.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
-#include "dds4ccm/impl/ndds/convertors/Duration_t.h"
-#include "dds4ccm/impl/ndds/convertors/Time_t.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandleSeq.h"
-#include "dds4ccm/impl/ndds/convertors/TopicBuiltinTopicData.h"
-#include "dds4ccm/impl/ndds/convertors/ParticipantBuiltinTopicData.h"
+#include "Utils.h"
+#include "StatusCondition.h"
+#include "DDSPublisherListener_T.h"
+#include "DDSSubscriberListener_T.h"
+#include "Topic_T.h"
+#include "TopicListener_T.h"
+#include "DomainParticipantListener.h"
+#include "DomainParticipantManager.h"
+
+#include "ndds/PublisherQos.h"
+#include "ndds/SubscriberQos.h"
+#include "ndds/TopicQos.h"
+#include "ndds/DomainParticipantQos.h"
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/Duration_t.h"
+#include "ndds/Time_t.h"
+#include "ndds/InstanceHandleSeq.h"
+#include "ndds/TopicBuiltinTopicData.h"
+#include "ndds/ParticipantBuiltinTopicData.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -34,34 +34,35 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::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 ("DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::DDS_DomainParticipant_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_DomainParticipant_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::~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 ("DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::~DDS_DomainParticipant_T");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_DomainParticipant_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_publisher_with_profile");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_publisher_with_profile");
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_publisher_with_profile - "
                     "Start creating Publisher\n"));
-      CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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,
@@ -77,7 +78,7 @@ namespace CIAO
       if (!ccm_dds_pub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_publisher_with_profile - "
                         "Error: Unable to create Publisher\n"));
           delete ccm_dds_pl;
@@ -91,31 +92,32 @@ namespace CIAO
 
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_publisher_with_profile - "
                     "Successfully created a DDSPublisher\n"));
 
       ccm_dds_pub->enable ();
       return retval._retn ();
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Publisher_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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_T::create_publisher");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_publisher");
       ACE_UNUSED_ARG (qos);
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_publisher - "
                     "Start creating Publisher\n"));
 
       DDS_PublisherQos ccm_dds_qos = DDS_PUBLISHER_QOS_DEFAULT;
 
-      CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_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,
@@ -131,8 +133,8 @@ namespace CIAO
       if (!ccm_dds_pub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                       "DDS_DomainParticipant_T"
-                       "<DDS_TYPE, VENDOR_TYPE>::create_publisher - "
+                       "CCM_DDS_DomainParticipant_T"
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_publisher - "
                        "Error: Unable to create Publisher\n"));
           delete ccm_dds_pl;
           return ::DDS::Publisher::_nil ();
@@ -144,7 +146,7 @@ namespace CIAO
                         ::CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_publisher - "
                     "Successfully created a DDSPublisher\n"));
 
@@ -152,9 +154,9 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::delete_publisher (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher (
       ::DDS::Publisher_ptr p)
     {
       Publisher_type *ccm_dds_pub =
@@ -163,32 +165,32 @@ namespace CIAO
       if (!ccm_dds_pub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T"
-                        "<DDS_TYPE, VENDOR_TYPE>::delete_publisher - "
+                        "CCM_DDS_DomainParticipant_T"
+                        "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                         "Unable to cast provided object reference to servant pointer.\n"));
           return ::DDS::RETCODE_ERROR;
         }
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                   "DDS_DomainParticipant_T"
-                   "<DDS_TYPE, VENDOR_TYPE>::delete_publisher - "
+                   "CCM_DDS_DomainParticipant_T"
+                   "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_publisher - "
                    "Successfully casted provided object reference to "
-                   "DDS_Publisher_T\n"));
+                   "CCM_DDS_Publisher_T\n"));
 
       DDS_ReturnCode_t const retval = this->impl ()->delete_publisher (ccm_dds_pub->get_impl ());
 
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T"
-                        "<DDS_TYPE, VENDOR_TYPE>::delete_publisher - "
+                        "CCM_DDS_DomainParticipant_T"
+                        "<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 (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_publisher - "
                         "Provided publisher successfully deleted\n"));
         }
@@ -196,19 +198,20 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_subscriber_with_profile");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_subscriber_with_profile");
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                   "DDS_DomainParticipant_T"
-                   "<DDS_TYPE, VENDOR_TYPE>::create_subscriber_with_profile - "
+                   "CCM_DDS_DomainParticipant_T"
+                   "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_subscriber_with_profile - "
                    "Creating Subscriber\n"));
 
       SubscriberListener_type *ccm_dds_sl = 0;
@@ -228,7 +231,7 @@ namespace CIAO
       if (!ccm_dds_sub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::"
+                        "CCM_DDS_DomainParticipant_T::"
                         "create_subscriber_with_profile - "
                         "Error: RTI DDS returned a nil subscriber.\n"));
           delete ccm_dds_sl;
@@ -241,27 +244,28 @@ namespace CIAO
                         ::CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_subscriber_with_profile - "
                     "Successfully created a DDSSubscriber\n"));
 
       ccm_dds_sub->enable ();
       return retval._retn ();
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::create_subscriber (
+    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_T::create_subscriber");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_subscriber");
 
       ACE_UNUSED_ARG (qos);
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_subscriber - "
                     "Creating Subscriber\n"));
 
@@ -282,7 +286,7 @@ namespace CIAO
       if (!ccm_dds_sub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::"
+                        "CCM_DDS_DomainParticipant_T::"
                         "create_subscriber_with_profile - "
                         "Error: RTI DDS returned a nil subscriber.\n"));
           delete ccm_dds_sl;
@@ -295,7 +299,7 @@ namespace CIAO
                         ::CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::create_subscriber - "
                     "Successfully created a DDSSubscriber\n"));
 
@@ -303,9 +307,9 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::delete_subscriber (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_subscriber (
       ::DDS::Subscriber_ptr s)
     {
       Subscriber_type *ccm_dds_sub = dynamic_cast < Subscriber_type * > (s);
@@ -313,14 +317,14 @@ namespace CIAO
       if (!ccm_dds_sub)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "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 (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::delete_subscriber - Successfully casted "
                     "provided object reference to Subscriber_type\n"));
 
@@ -329,7 +333,7 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "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)));
@@ -337,7 +341,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_subscriber - "
                         "Provided subscriber successfully deleted\n"));
         }
@@ -345,9 +349,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Subscriber_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_builtin_subscriber (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_builtin_subscriber (void)
     {
       ::DDS::Subscriber_var retval;
       DDSSubscriber* sub = this->impl ()->get_builtin_subscriber ();
@@ -360,21 +364,21 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::create_topic (
+    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,
                                             ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_topic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_topic");
 
       ACE_UNUSED_ARG (qos);
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_DEBUG, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T::create_topic - "
+                    "CCM_DDS_DomainParticipant_T::create_topic - "
                     "Attempting to create topic with name %C and type %C\n",
                     impl_name, type_name));
 
@@ -407,7 +411,7 @@ namespace CIAO
           if (!dds_tp)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_DomainParticipant_T::create_topic - "
+                            "CCM_DDS_DomainParticipant_T::create_topic - "
                             "Error: RTI DDS returned a nil topic\n"));
               delete ccm_dds_tl;
               return ::DDS::Topic::_nil ();
@@ -419,7 +423,7 @@ namespace CIAO
                             ::CORBA::NO_MEMORY ());
 
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic - "
+                        "CCM_DDS_DomainParticipant_T::create_topic - "
                         "Successfully created topic with name %C and type %C\n",
                         impl_name, type_name));
 
@@ -434,7 +438,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic - "
+                        "CCM_DDS_DomainParticipant_T::create_topic - "
                         "Re-using topic with name %C and type %C.\n",
                         impl_name, type_name));
 
@@ -449,9 +453,10 @@ namespace CIAO
         }
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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,
@@ -459,12 +464,12 @@ namespace CIAO
         ::DDS::TopicListener_ptr a_listener,
         ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_topic_with_profile");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_topic_with_profile");
 
       if (impl_name == 0)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic_with_profile - "
+                        "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                         "Error: provided nil topic name\n"));
           throw ::CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
         }
@@ -472,13 +477,13 @@ namespace CIAO
       if (type_name == 0)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic_with_profile - "
+                        "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                         "Error: provided nil type name\n"));
           throw ::CCM_DDS::InternalError (::DDS::RETCODE_BAD_PARAMETER, 0);
         }
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_DEBUG, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T::create_topic_with_profile - "
+                    "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                     "Attempting to create topic with name %C and type %C\n",
                     impl_name, type_name));
 
@@ -511,7 +516,7 @@ namespace CIAO
           if (!dds_tp)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_DomainParticipant_T::create_topic_with_profile - "
+                            "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                             "Error: RTI DDS returned a nil topic\n"));
               delete ccm_dds_tl;
               return ::DDS::Topic::_nil ();
@@ -523,7 +528,7 @@ namespace CIAO
                             ::CORBA::NO_MEMORY ());
 
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic_with_profile - "
+                        "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                         "Successfully created topic with name %C and type %C\n",
                         impl_name, type_name));
 
@@ -538,7 +543,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T::create_topic_with_profile - "
+                        "CCM_DDS_DomainParticipant_T::create_topic_with_profile - "
                         "Re-using topic with name %C and type %C.\n",
                         impl_name, type_name));
           DPMANAGER->_inc_ref (this->impl (), dds_tp);
@@ -550,12 +555,13 @@ namespace CIAO
           return retval._retn ();
         }
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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_T::delete_topic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::delete_topic");
       CORBA::String_var topic_name = a_topic->get_name ();
       DDSTopicDescription * dds_td =
         this->impl ()->lookup_topicdescription (topic_name.in ());
@@ -568,7 +574,7 @@ namespace CIAO
       if (!tp)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_topic <%C> - Unable to cast "
                         "provided object reference to servant.\n",
                         topic_name.in ()));
@@ -576,7 +582,7 @@ namespace CIAO
         }
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::delete_topic <%C> - "
                     "Successfully casted provided object reference to servant.\n",
                     topic_name.in ()));
@@ -589,7 +595,7 @@ namespace CIAO
           if (retval != DDS_RETCODE_OK)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_DomainParticipant_T<DDS_TYPE, "
+                            "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.in (),
@@ -598,7 +604,7 @@ namespace CIAO
           else
             {
               DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                            "DDS_DomainParticipant_T<DDS_TYPE, "
+                            "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                             "VENDOR_TYPE>::delete_topic <%C> - "
                             "Provided topic successfully deleted\n",
                             topic_name.in ()));
@@ -607,9 +613,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::Topic_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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;
@@ -625,14 +631,14 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicDescription_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::lookup_topicdescription (const char * name)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_topicdescription (const char * name)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::lookup_topicdescription");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_topicdescription");
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_UNIMP_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T<DDS_TYPE, "
+                    "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::lookup_topicdescription - "
                     "Looking up topic: name <%C>\n",
                     name));
@@ -664,20 +670,21 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ContentFilteredTopic_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_contentfilteredtopic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_contentfilteredtopic");
 
+#if (CIAO_DDS4CCM_NDDS==1)
       Topic_type *top = dynamic_cast< Topic_type *> (related_topic);
       if (!top)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "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);
@@ -704,7 +711,7 @@ namespace CIAO
       if (!ccm_dds_cft)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "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",
@@ -718,26 +725,32 @@ namespace CIAO
                         ::CORBA::NO_MEMORY ());
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                    "DDS_DomainParticipant_T::create_contentfilteredtopic - "
+                    "CCM_DDS_DomainParticipant_T::create_contentfilteredtopic - "
                     "Successfully created contentfilteredtopic with name <%C> and "
                     "filter expression <%C>\n",
                     name, filter_expression));
 
       return retval._retn ();
+#else
+      return this->impl ()->create_contentfilteredtopic (name,
+                                                         related_topic,
+                                                         filter_expression,
+                                                         expression_parameters);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::delete_contentfilteredtopic (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_contentfilteredtopic (
       ::DDS::ContentFilteredTopic_ptr a_contentfilteredtopic)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::delete_contentfilteredtopic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::delete_contentfilteredtopic");
       ContentFilteredTopic_type *ccm_dds_cft =
           dynamic_cast < ContentFilteredTopic_type *> (a_contentfilteredtopic);
       if (!ccm_dds_cft)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_contentfilteredtopic - "
                         "Unable to cast provided ContentFilteredTopic.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
@@ -745,68 +758,83 @@ namespace CIAO
       return this->impl ()->delete_contentfilteredtopic (ccm_dds_cft->get_impl ());
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::MultiTopic_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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,
       const ::DDS::StringSeq & expression_parameters)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::create_multitopic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::create_multitopic");
+#if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (name);
       ACE_UNUSED_ARG (type_name);
       ACE_UNUSED_ARG (subscription_expression);
       ACE_UNUSED_ARG (expression_parameters);
       //Not implemented in version ndds.4.5b.rev01 of RTI DDS.
       throw ::CORBA::NO_IMPLEMENT ();
+#else
+      return this->impl ()->create_multitopic (name,
+                                               type_name,
+                                               subscription_expression,
+                                               expression_parameters);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::delete_multitopic (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_multitopic (
       ::DDS::MultiTopic_ptr a_multitopic)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::delete_multitopic");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::delete_multitopic");
+#if (CIAO_DDS4CCM_NDDS==1)
       ACE_UNUSED_ARG (a_multitopic);
       //Not implemented in version ndds.4.5b.rev01 of RTI DDS.
       throw ::CORBA::NO_IMPLEMENT ();
+#else
+      return this->impl ()->delete_multitopic (a_multitopic);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
       const ::DDS::DomainParticipantQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::set_qos");
+#if (CIAO_DDS4CCM_NDDS==1)
       ::DDS_DomainParticipantQos 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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
       ::DDS::DomainParticipantQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::get_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_qos");
       ::DDS_DomainParticipantQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl()-> get_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_listener (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
                 ::DDS::DomainParticipantListener_ptr a_listener,
                 ::DDS::StatusMask mask)
     {
@@ -824,11 +852,11 @@ namespace CIAO
       return this->impl_->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipantListener_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_listener");
 
       DDSDomainParticipantListener *ccm_dds_dp_list = this->impl ()->get_listener ();
       CCM_DDS_DomainParticipantListener_i * list_proxy =
@@ -836,7 +864,7 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_DomainParticipant_T<DDS_TYPE, "
+                        "CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::get_listener - "
                         "DDS returned a NIL listener.\n"));
           return ::DDS::DomainParticipantListener::_nil ();
@@ -844,9 +872,9 @@ namespace CIAO
       return list_proxy->get_domainparticipantlistener ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::ignore_participant (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_participant (
       DDS_INSTANCE_HANDLE_T_IN handle)
     {
       ::DDS_InstanceHandle_t ccm_dds_handle;
@@ -854,9 +882,9 @@ namespace CIAO
       return this->impl ()->ignore_participant (ccm_dds_handle);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::ignore_topic (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_topic (
       DDS_INSTANCE_HANDLE_T_IN handle)
     {
       ::DDS_InstanceHandle_t ccm_dds_handle;
@@ -864,9 +892,9 @@ namespace CIAO
       return this->impl ()->ignore_topic (ccm_dds_handle);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::ignore_publication (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_publication (
       DDS_INSTANCE_HANDLE_T_IN handle)
     {
       ::DDS_InstanceHandle_t ccm_dds_handle;
@@ -874,9 +902,9 @@ namespace CIAO
       return this->impl ()->ignore_publication (ccm_dds_handle);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::ignore_subscription (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::ignore_subscription (
       DDS_INSTANCE_HANDLE_T_IN handle)
     {
       ::DDS_InstanceHandle_t ccm_dds_handle;
@@ -884,60 +912,60 @@ namespace CIAO
       return this->impl ()->ignore_subscription (ccm_dds_handle);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainId_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_default_publisher_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_publisher_qos (
       const ::DDS::PublisherQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::set_default_publisher_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::set_default_publisher_qos");
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_publisher_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_default_publisher_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_publisher_qos (
       ::DDS::PublisherQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::get_default_publisher_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_default_publisher_qos");
       ::DDS_PublisherQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl()-> get_default_publisher_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_default_subscriber_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_subscriber_qos (
       const ::DDS::SubscriberQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::set_default_subscriber_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::set_default_subscriber_qos");
       ::DDS_SubscriberQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_subscriber_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_default_subscriber_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_subscriber_qos (
       ::DDS::SubscriberQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::get_default_subscriber_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_default_subscriber_qos");
       ::DDS_SubscriberQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
             this->impl()-> get_default_subscriber_qos (ccm_dds_qos);
@@ -945,23 +973,23 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_default_topic_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_topic_qos (
       const ::DDS::TopicQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::set_default_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::set_default_topic_qos");
       ::DDS_TopicQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_topic_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_default_topic_qos (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_topic_qos (
       ::DDS::TopicQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_DomainParticipant_T::get_default_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_default_topic_qos");
       ::DDS_TopicQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
             this->impl()-> get_default_topic_qos (ccm_dds_qos);
@@ -969,9 +997,9 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_discovered_participants (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_discovered_participants (
       ::DDS::InstanceHandleSeq & impl_handles)
     {
       ::DDS_InstanceHandleSeq rtiseq;
@@ -980,13 +1008,13 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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_T::get_discovered_participant_data");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_discovered_participant_data");
       DDS_ParticipantBuiltinTopicData dds_part_data;
       dds_part_data <<= impl_data;
       ::DDS_InstanceHandle_t dds_hnd;
@@ -998,24 +1026,28 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_discovered_topics (
+    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;
       ::DDS::ReturnCode_t const retval = this->impl ()->get_discovered_topics (rtiseq);
       impl_handles <<= rtiseq;
       return retval;
+#else
+      return this->impl ()->get_discovered_topics (impl_handles);
+#endif
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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_T::get_discovered_topic_data");
+      DDS4CCM_TRACE ("CCM_DDS_DomainParticipant_T::get_discovered_topic_data");
       DDS_TopicBuiltinTopicData dds_tp_data;
       dds_tp_data <<= impl_data;
       ::DDS_InstanceHandle_t dds_hnd;
@@ -1027,9 +1059,9 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::CORBA::Boolean
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::contains_entity (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::contains_entity (
       DDS_INSTANCE_HANDLE_T_IN a_handle)
     {
       ::DDS_InstanceHandle_t ccm_dds_handle;
@@ -1037,9 +1069,9 @@ namespace CIAO
       return this->impl ()->contains_entity (ccm_dds_handle);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_current_time (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_current_time (
       ::DDS::Time_t & current_time)
     {
       DDS_Time_t ccm_dds_time;
@@ -1048,38 +1080,38 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval;
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       if (sc)
         {
           ACE_NEW_THROW_EX (retval,
-                            DDS_StatusCondition_i (sc),
+                            CCM_DDS_StatusCondition_i (sc),
                             ::CORBA::NO_MEMORY ());
         }
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDS_INSTANCE_HANDLE_T_RETN
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
@@ -1087,24 +1119,24 @@ namespace CIAO
       return handle;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDomainParticipant *
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_TYPE>::set_impl (
+    CCM_DDS_DomainParticipant_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (
       DDSDomainParticipant * dp)
     {
       this->impl_ = dp;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDomainParticipant *
-    DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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/ndds/DomainParticipant_T.h b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h
index 06d68743159..e7ee1757952 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipant_T.h
+++ b/CIAO/connectors/dds4ccm/impl/DomainParticipant_T.h
@@ -12,71 +12,77 @@
 
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/idl/dds_rtf2_dcpsEC.h"
-#include "convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
 #include "tao/LocalObject.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
+#include "ndds/ndds_cpp.h"
+#endif
+
 namespace CIAO
 {
   namespace DDS4CCM
   {
     // Forward declarations
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Publisher_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Publisher_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Subscriber_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Subscriber_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_TopicListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ContentFilteredTopic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T;
 
     // Class declaration
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipant_T :
-      public virtual ::DDS::DomainParticipant,
+    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 DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE> Subscriber_type;
-    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_TYPE> SubscriberListener_type;
-    typedef DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE> Publisher_type;
-    typedef CCM_DDS_PublisherListener_T<DDS_TYPE, VENDOR_TYPE> PublisherListener_type;
-    typedef CCM_DDS_TopicListener_T<DDS_TYPE, VENDOR_TYPE> TopicListener_type;
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_TYPE> Topic_type;
-    typedef DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_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
-      DDS_DomainParticipant_T (DDSDomainParticipant * dp);
+      CCM_DDS_DomainParticipant_T (DDSDomainParticipant * dp);
 
       /// Destructor
-      virtual ~DDS_DomainParticipant_T (void);
+      virtual ~CCM_DDS_DomainParticipant_T (void);
 
       virtual ::DDS::Publisher_ptr create_publisher (
         const ::DDS::PublisherQos & qos,
         ::DDS::PublisherListener_ptr a_listener,
         ::DDS::StatusMask mask);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::Publisher_ptr create_publisher_with_profile (
         const char* library_name,
         const char *profile_name,
         ::DDS::PublisherListener_ptr a_listener,
         ::DDS::StatusMask mask);
+#endif
 
       virtual ::DDS::ReturnCode_t delete_publisher (::DDS::Publisher_ptr p);
 
@@ -85,11 +91,13 @@ namespace CIAO
         ::DDS::SubscriberListener_ptr a_listener,
         ::DDS::StatusMask mask);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::Subscriber_ptr create_subscriber_with_profile(
         const char* library_name,
         const char *profile_name,
         ::DDS::SubscriberListener_ptr a_listener,
         ::DDS::StatusMask mask);
+#endif
 
       virtual ::DDS::ReturnCode_t delete_subscriber (::DDS::Subscriber_ptr s);
 
@@ -102,6 +110,7 @@ namespace CIAO
         ::DDS::TopicListener_ptr a_listener,
         ::DDS::StatusMask mask);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::Topic_ptr create_topic_with_profile (
         const char * impl_name,
         const char * type_name,
@@ -109,6 +118,7 @@ namespace CIAO
         const char *profile_name,
         ::DDS::TopicListener_ptr a_listener,
         ::DDS::StatusMask mask);
+#endif
 
       virtual ::DDS::ReturnCode_t delete_topic (::DDS::Topic_ptr a_topic);
 
@@ -225,6 +235,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/DomainParticipant_T.cpp"
+#include "dds4ccm/impl/DomainParticipant_T.cpp"
 
 #endif /* DOMAINPARTICIPANT_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/Getter_T.cpp b/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
index dd037175682..28c01aa7590 100644
--- a/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Getter_T.cpp
@@ -1,8 +1,8 @@
 // $Id$
 #include "dds4ccm/impl/Utils.h"
 
-#include "dds4ccm/impl/ndds/convertors/Duration_t.h"
-#include "dds4ccm/impl/ndds/convertors/SampleInfo.h"
+#include "dds4ccm/impl/ndds/Duration_t.h"
+#include "dds4ccm/impl/ndds/SampleInfo.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
@@ -22,7 +22,7 @@ CIAO::DDS4CCM::DDS_CCM::Getter_Base_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~Getter_
 }
 
 template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, 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_)
diff --git a/CIAO/connectors/dds4ccm/impl/Getter_T.h b/CIAO/connectors/dds4ccm/impl/Getter_T.h
index 397d575ea70..de8336bda3b 100644
--- a/CIAO/connectors/dds4ccm/impl/Getter_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Getter_T.h
@@ -47,9 +47,9 @@ namespace CIAO
          public virtual LocalObject_T<CCM_TYPE>,
          private virtual ACE_Copy_Disabled
       {
-      typedef CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>
+      typedef CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
         ReadCondition_type;
-      typedef CIAO::DDS4CCM::DataReader_T<DDS_TYPE, VENDOR_TYPE>
+      typedef CIAO::DDS4CCM::DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
         DataReader_type;
       typedef CIAO::DDS4CCM::ConditionManager_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
         ConditionManager_type;
diff --git a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
index 920abe1e063..e7aa8df4837 100644
--- a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.cpp
@@ -1,8 +1,8 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "dds4ccm/impl/DataWriter_T.h"
 #include "dds4ccm/impl/Utils.h"
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
 template <typename DDS_TYPE, typename CCM_TYPE, typename BASE_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
@@ -56,7 +56,7 @@ CIAO::DDS4CCM::InstanceHandleManager_T<DDS_TYPE, CCM_TYPE, BASE_TYPE, VENDOR_TYP
 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, VENDOR_TYPE>::set_impl (
-  DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE> *writer)
+  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 d98f307dd6f..b72b300c574 100644
--- a/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h
+++ b/CIAO/connectors/dds4ccm/impl/InstanceHandleManager_T.h
@@ -37,7 +37,7 @@ namespace CIAO
         const typename DDS_TYPE::value_type & datum,
         const ::DDS::InstanceHandle_t & instance_handle);
 
-      void set_impl (DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE> *writer);
+      void set_impl (CCM_DDS_DataWriter_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> *writer);
 
       typename DDS_TYPE::datawriter_type * impl (void);
 
diff --git a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
index 100ecb881b9..470b05815df 100644
--- a/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/PublisherListener_T.h
@@ -11,7 +11,6 @@
 #define PUBLISHERLISTENER_T_H_
 
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
-#include "dds4ccm/idl/ccm_ddsC.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 #include "ace/Copy_Disabled.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/Publisher_T.cpp b/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp
index 37f7ea06db5..2410c4e49d2 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Publisher_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Publisher_T.cpp
@@ -1,18 +1,18 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/Publisher_T.h"
-#include "dds4ccm/impl/PublisherListener_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/Utils.h"
-#include "dds4ccm/impl/DDSDataWriterListener_T.h"
-
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
-#include "dds4ccm/impl/ndds/convertors/Duration_t.h"
-#include "dds4ccm/impl/ndds/convertors/DataWriterQos.h"
-#include "dds4ccm/impl/ndds/convertors/PublisherQos.h"
-#include "dds4ccm/impl/ndds/convertors/TopicQos.h"
+#include "Publisher_T.h"
+#include "PublisherListener_T.h"
+#include "Topic_T.h"
+#include "DataWriter_T.h"
+#include "StatusCondition.h"
+#include "Utils.h"
+#include "DDSDataWriterListener_T.h"
+
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/Duration_t.h"
+#include "ndds/DataWriterQos.h"
+#include "ndds/PublisherQos.h"
+#include "ndds/TopicQos.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -22,35 +22,35 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::DDS_Publisher_T");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Publisher_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::~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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::~DDS_Publisher_T");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Publisher_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::create_datawriter (
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter (
       ::DDS::Topic_ptr a_topic,
       const ::DDS::DataWriterQos &,
       ::DDS::DataWriterListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_Publisher_T<DDS_TYPE, VENDOR_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 (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "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 (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_datawriter - "
                         "Error: RTI Topic returned a nil datawriter.\n"));
           delete ccm_dds_drl;
@@ -89,22 +89,23 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::create_datawriter_with_profile");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datawriter_with_profile");
 
       Topic_type * topic = dynamic_cast < Topic_type * > (a_topic);
 
       if (!topic)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<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);
@@ -127,7 +128,7 @@ namespace CIAO
       if (!ccm_dds_dw)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_datawriter_with_profile - "
                         "Error: RTI Topic returned a nil datawriter.\n"));
           delete ccm_dds_drl;
@@ -136,7 +137,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_datawriter_with_profile - "
                         "Successfully created datawriter with profile <%C#%C>.\n",
                         library_name,
@@ -151,26 +152,27 @@ namespace CIAO
 
       return retval._retn ();
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::delete_datawriter");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::delete_datawriter");
 
       DataWriter_type *top = dynamic_cast< DataWriter_type * > (a_datawriter);
 
       if (!top)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datawriter - "
                         "Unable to cast provided object reference to servant.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_Publisher_T<DDS_TYPE, "
+                    "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::delete_datawriter - "
                     "Successfully casted provided object reference to servant.\n"));
 
@@ -179,7 +181,7 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datawriter - "
                         "Error: RTI delete_datawriter returned non-ok error code %C\n",
                         translate_retcode (retval)));
@@ -187,7 +189,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datawriter - "
                         "Provided datawriter successfully deleted\n"));
         }
@@ -195,9 +197,9 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataWriter_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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;
       DDSDataWriter* dw = this->impl ()->lookup_datawriter (impl_name);
@@ -207,28 +209,28 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl ()->set_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_qos (::DDS::PublisherQos & qos)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::PublisherQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
       ::DDS_PublisherQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       ::DDS::ReturnCode_t retcode = this->impl()->
@@ -237,13 +239,13 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::set_listener (
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener (
       ::DDS::PublisherListener_ptr a_listener,
       ::DDS::StatusMask mask)
     {
-      DDS4CCM_TRACE ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
       // Delete the previously set listener
       DDSPublisherListener *listener = this->impl ()->get_listener ();
@@ -259,11 +261,11 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::PublisherListener_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
       DDSPublisherListener *ccm_dds_pub_list = this->impl ()->get_listener ();
       PublisherListener_type * list_proxy =
@@ -271,7 +273,7 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Publisher_T<DDS_TYPE, "
+                        "CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::get_listener - "
                         "DDS returned a NIL listener.\n"));
           return ::DDS::PublisherListener::_nil ();
@@ -279,37 +281,37 @@ namespace CIAO
       return list_proxy->get_publisher_listener ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::wait_for_acknowledgments (
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::wait_for_acknowledgments (
       const ::DDS::Duration_t & max_wait)
     {
       DDS_Duration_t ccm_dds_dds_duration;
@@ -317,11 +319,11 @@ namespace CIAO
       return this->impl ()->wait_for_acknowledgments (ccm_dds_dds_duration);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_participant (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
-      DDS4CCM_TRACE ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_participant");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant");
       ::DDS::DomainParticipant_var retval;
       DDSDomainParticipant* p = this->impl ()->get_participant ();
       ACE_NEW_THROW_EX (retval,
@@ -330,21 +332,21 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::set_default_datawriter_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datawriter_qos");
       ::DDS_DataWriterQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl()->set_default_datawriter_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_default_datawriter_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datawriter_qos");
       ::DDS_DataWriterQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode =
             this->impl()->get_default_datawriter_qos (ccm_dds_qos);
@@ -352,12 +354,12 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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 ("DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
       ::DDS_DataWriterQos ccm_dds_qos;
       ::DDS_TopicQos ccm_dds_topic_qos;
 
@@ -369,35 +371,35 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval;
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       ACE_NEW_THROW_EX (retval,
-                        DDS_StatusCondition_i (sc),
+                        CCM_DDS_StatusCondition_i (sc),
                         ::CORBA::NO_MEMORY ());
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
@@ -405,23 +407,23 @@ namespace CIAO
       return handle;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSPublisher *
-    DDS_Publisher_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
+    CCM_DDS_Publisher_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSPublisher *
-    DDS_Publisher_T<DDS_TYPE, VENDOR_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/ndds/Publisher_T.h b/CIAO/connectors/dds4ccm/impl/Publisher_T.h
index 0a00e84c0e0..35b02ce6b0a 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Publisher_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Publisher_T.h
@@ -15,42 +15,48 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 # include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::Publisher DDSPublisher;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DataWriter_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DataWriter_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_DataWriterListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_PublisherListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipant_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Publisher_T :
-      public virtual ::DDS::Publisher,
+    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 DDS_Topic_T<DDS_TYPE, VENDOR_TYPE> Topic_type;
+    typedef CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> Topic_type;
 
-    typedef DDS_DataWriter_T<DDS_TYPE, VENDOR_TYPE> DataWriter_type;
-    typedef CCM_DDS_DataWriterListener_T<DDS_TYPE, VENDOR_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, VENDOR_TYPE> PublisherListener_type;
-    typedef DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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
-      DDS_Publisher_T (DDSPublisher * dw);
+      CCM_DDS_Publisher_T (DDSPublisher * dw);
 
       /// Destructor
-      virtual ~DDS_Publisher_T (void);
+      virtual ~CCM_DDS_Publisher_T (void);
 
       virtual
         ::DDS::DataWriter_ptr create_datawriter (::DDS::Topic_ptr a_topic,
@@ -139,6 +145,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/Publisher_T.cpp"
+#include "dds4ccm/impl/Publisher_T.cpp"
 
 #endif /* PUBLISHER_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp
new file mode 100644
index 00000000000..b2481d94a7b
--- /dev/null
+++ b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.cpp
@@ -0,0 +1,138 @@
+// $Id$
+
+#include "QueryCondition_T.h"
+#include "Subscriber_T.h"
+
+#include "ndds/StringSeq.h"
+
+#include "dds4ccm/idl/dds4ccm_BaseC.h"
+
+#include "dds4ccm/impl/Log_Macros.h"
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_QueryCondition_T (DDSQueryCondition * qc)
+  : impl_ (qc)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::CCM_DDS_QueryCondition_T");
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_QueryCondition_T (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::~CCM_DDS_QueryCondition_T");
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::CORBA::Boolean
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_trigger_value (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_trigger_value");
+
+  return this->impl ()->get_trigger_value ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::SampleStateMask
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_sample_state_mask");
+
+  return this->impl ()->get_sample_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::ViewStateMask
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_view_state_mask");
+
+  return this->impl ()->get_view_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::InstanceStateMask
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_instance_state_mask");
+
+  return this->impl ()->get_instance_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::DataReader_ptr
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_datareader");
+
+  ::DDS::DataReader_var dds_reader;
+  DDSDataReader* reader = this->impl ()->get_datareader ();
+  if (reader)
+    {
+      ACE_NEW_THROW_EX (dds_reader,
+                        DataReader_type (reader),
+                        ::CORBA::NO_MEMORY ());
+    }
+  return dds_reader._retn ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+char *
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_query_expression (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_query_expression");
+
+  return ::CORBA::string_dup (this->impl ()->get_query_expression ());
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::ReturnCode_t
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_query_parameters (
+  ::DDS::StringSeq & query_parameters)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::get_query_parameters");
+
+  DDS_StringSeq parameters;
+  ::DDS::ReturnCode_t const retval =
+    this->impl ()->get_query_parameters (parameters);
+  query_parameters <<= parameters;
+  return retval;
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::ReturnCode_t
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_query_parameters (
+  const ::DDS::StringSeq & query_parameters)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_QueryCondition_T::set_query_parameters");
+
+  DDS_StringSeq parameters;
+  parameters <<= query_parameters;
+
+  return this->impl ()->set_query_parameters (parameters);
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDSQueryCondition *
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
+{
+  return this->impl_;
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+void
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSQueryCondition * dw)
+{
+  this->impl_ = dw;
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDSQueryCondition *
+CIAO::DDS4CCM::CCM_DDS_QueryCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
+{
+  if (!this->impl_)
+    {
+      throw ::CORBA::BAD_INV_ORDER ();
+    }
+  return this->impl_;
+}
+
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/QueryCondition_T.h b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h
index 4ca29a39886..b1004c4d861 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/QueryCondition_T.h
+++ b/CIAO/connectors/dds4ccm/impl/QueryCondition_T.h
@@ -15,28 +15,34 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::QueryCondition DDSQueryCondition;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_QueryCondition_T :
-      public virtual ::DDS::QueryCondition,
+    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, VENDOR_TYPE> DataReader_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
 
     public:
       /// Constructor
-      DDS_QueryCondition_T (DDSQueryCondition * qc);
+      CCM_DDS_QueryCondition_T (DDSQueryCondition * qc);
 
       /// Destructor
-      virtual ~DDS_QueryCondition_T (void);
+      virtual ~CCM_DDS_QueryCondition_T (void);
 
       virtual ::CORBA::Boolean get_trigger_value (void);
 
@@ -68,6 +74,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/QueryCondition_T.cpp"
+#include "dds4ccm/impl/QueryCondition_T.cpp"
 
 #endif /* QUERYCONDITION_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp
new file mode 100644
index 00000000000..18d4f50e6b6
--- /dev/null
+++ b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.cpp
@@ -0,0 +1,97 @@
+// $Id$
+
+#include "ReadCondition_T.h"
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_ReadCondition_T (
+  DDSReadCondition * rc)
+  : impl_ (rc)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::CCM_DDS_ReadCondition_T");
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_ReadCondition_T (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::~CCM_DDS_ReadCondition_T");
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::CORBA::Boolean
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_trigger_value (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::get_trigger_value");
+
+  return this->impl ()->get_trigger_value ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::SampleStateMask
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::get_sample_state_mask");
+
+  return this->impl ()->get_sample_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::ViewStateMask
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::get_view_state_mask");
+
+  return this->impl ()->get_view_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::InstanceStateMask
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::get_instance_state_mask");
+
+  return this->impl ()->get_instance_state_mask ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+::DDS::DataReader_ptr
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_datareader (void)
+{
+  DDS4CCM_TRACE ("CIAO::DDS4CCM::CCM_DDS_ReadCondition_T::get_datareader");
+
+  ::DDS::DataReader_var retval;
+  DDSDataReader* rd = this->impl ()->get_datareader ();
+  if (rd)
+    {
+      ACE_NEW_THROW_EX (retval,
+                        DataReader_type (rd),
+                        ::CORBA::NO_MEMORY ());
+    }
+  return retval._retn ();
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDSReadCondition *
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
+{
+  return this->impl_;
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+void
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (
+  DDSReadCondition * rc)
+{
+  this->impl_ = rc;
+}
+
+template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+DDSReadCondition *
+CIAO::DDS4CCM::CCM_DDS_ReadCondition_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
+{
+  if (!this->impl_)
+    {
+      throw ::CORBA::BAD_INV_ORDER ();
+    }
+  return this->impl_;
+}
+
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/ReadCondition_T.h b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h
index e63ab55c96a..cc008303eda 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/ReadCondition_T.h
+++ b/CIAO/connectors/dds4ccm/impl/ReadCondition_T.h
@@ -15,28 +15,34 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ReadCondition DDSReadCondition;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class DataReader_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ReadCondition_T :
+    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, VENDOR_TYPE> DataReader_type;
+    typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DataReader_type;
 
     public:
       /// Constructor
-      DDS_ReadCondition_T (DDSReadCondition * rc);
+      CCM_DDS_ReadCondition_T (DDSReadCondition * rc);
 
       /// Destructor
-      virtual ~DDS_ReadCondition_T (void);
+      virtual ~CCM_DDS_ReadCondition_T (void);
 
       virtual ::CORBA::Boolean get_trigger_value (void);
 
@@ -60,6 +66,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/ReadCondition_T.cpp"
+#include "dds4ccm/impl/ReadCondition_T.cpp"
 
 #endif /* READCONDITION_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/Reader_T.cpp b/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
index fca0f07ce03..e8c22c11039 100644
--- a/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Reader_T.cpp
@@ -1,10 +1,10 @@
 // $Id$
 
 #include "dds4ccm/impl/Utils.h"
-#include "dds4ccm/impl/ndds/DataReader_T.h"
+#include "dds4ccm/impl/DataReader_T.h"
 
-#include "dds4ccm/impl/ndds/convertors/SampleInfo.h"
-#include "dds4ccm/impl/ndds/convertors/StringSeq.h"
+#include "dds4ccm/impl/ndds/SampleInfo.h"
+#include "dds4ccm/impl/ndds/StringSeq.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
@@ -297,7 +297,7 @@ CIAO::DDS4CCM::DDS_CCM::Reader_T<DDS_TYPE, CCM_TYPE, FIXED, VENDOR_TYPE>::set_im
 }
 
 template <typename DDS_TYPE, typename CCM_TYPE, bool FIXED, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DataReader_T<DDS_TYPE, 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 f2d6c872949..eae1eda2bcc 100644
--- a/CIAO/connectors/dds4ccm/impl/Reader_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Reader_T.h
@@ -32,7 +32,8 @@ namespace CIAO
           public virtual LocalObject_T<CCM_TYPE>,
           private virtual ACE_Copy_Disabled
       {
-      typedef DataReader_T<DDS_TYPE, VENDOR_TYPE> DataReader_type;
+      typedef DataReader_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
+        DataReader_type;
       typedef ConditionManager_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>
         ConditionManager_type;
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/StatusCondition.cpp b/CIAO/connectors/dds4ccm/impl/StatusCondition.cpp
index b1e06cf642e..3dcf2c7fc4e 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/StatusCondition.cpp
+++ b/CIAO/connectors/dds4ccm/impl/StatusCondition.cpp
@@ -11,55 +11,55 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    DDS_StatusCondition_i::DDS_StatusCondition_i (
+    CCM_DDS_StatusCondition_i::CCM_DDS_StatusCondition_i (
       DDSStatusCondition * sc) :
       impl_ (sc)
     {
     }
 
-    DDS_StatusCondition_i::~DDS_StatusCondition_i (void)
+    CCM_DDS_StatusCondition_i::~CCM_DDS_StatusCondition_i (void)
     {
     }
 
     ::CORBA::Boolean
-    DDS_StatusCondition_i::get_trigger_value (void)
+    CCM_DDS_StatusCondition_i::get_trigger_value (void)
     {
       return this->impl ()->get_trigger_value ();
     }
 
     ::DDS::StatusMask
-    DDS_StatusCondition_i::get_enabled_statuses (void)
+    CCM_DDS_StatusCondition_i::get_enabled_statuses (void)
     {
       return this->impl ()->get_enabled_statuses ();
     }
 
     ::DDS::ReturnCode_t
-    DDS_StatusCondition_i::set_enabled_statuses (
+    CCM_DDS_StatusCondition_i::set_enabled_statuses (
       ::DDS::StatusMask mask)
     {
       return this->impl ()->set_enabled_statuses (mask);
     }
 
     ::DDS::Entity_ptr
-    DDS_StatusCondition_i::get_entity (void)
+    CCM_DDS_StatusCondition_i::get_entity (void)
     {
       throw ::CORBA::NO_IMPLEMENT ();
     }
 
     DDSStatusCondition *
-    DDS_StatusCondition_i::get_impl (void)
+    CCM_DDS_StatusCondition_i::get_impl (void)
     {
       return this->impl_;
     }
 
     void
-    DDS_StatusCondition_i::set_impl (DDSStatusCondition * sc)
+    CCM_DDS_StatusCondition_i::set_impl (DDSStatusCondition * sc)
     {
       this->impl_ = sc;
     }
 
     DDSStatusCondition *
-    DDS_StatusCondition_i::impl (void)
+    CCM_DDS_StatusCondition_i::impl (void)
     {
       if (!this->impl_)
         {
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/StatusCondition.h b/CIAO/connectors/dds4ccm/impl/StatusCondition.h
index c15e3a10168..c8dcda897c1 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/StatusCondition.h
+++ b/CIAO/connectors/dds4ccm/impl/StatusCondition.h
@@ -13,27 +13,33 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsEC.h"
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 
-#include "dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h"
+#include "dds4ccm/impl/dds4ccm_dds_impl_export.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
 #include "tao/LocalObject.h"
 
-#include "ndds/ndds_cpp.h"
+#if (CIAO_DDS4CCM_NDDS==1)
+# include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::StatusCondition DDSStatusCondition;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    class DDS4CCM_DDS_NDDS_Export DDS_StatusCondition_i :
-      public virtual ::DDS::StatusCondition,
+    class DDS4CCM_DDS_IMPL_Export CCM_DDS_StatusCondition_i :
+      public virtual ::DDS::CCM_StatusCondition,
       public virtual ::CORBA::LocalObject
     {
     public:
       /// Constructor
-      DDS_StatusCondition_i (DDSStatusCondition *sc);
+      CCM_DDS_StatusCondition_i (DDSStatusCondition *sc);
 
       /// Destructor
-      virtual ~DDS_StatusCondition_i (void);
+      virtual ~CCM_DDS_StatusCondition_i (void);
 
       virtual ::CORBA::Boolean get_trigger_value (void);
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/SubscriberListener_T.cpp b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp
index c4900296433..c4900296433 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/SubscriberListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.cpp
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/SubscriberListener_T.h b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h
index ad663134212..2802456eaa3 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/SubscriberListener_T.h
+++ b/CIAO/connectors/dds4ccm/impl/SubscriberListener_T.h
@@ -24,7 +24,7 @@ namespace CIAO
   {
     template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class SubscriberListener_T :
-      public ::DDS::SubscriberListener,
+      public ::DDS::CCM_SubscriberListener,
       private ACE_Copy_Disabled
     {
     public:
@@ -81,6 +81,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/SubscriberListener_T.cpp"
+#include "dds4ccm/impl/SubscriberListener_T.cpp"
 
 #endif /* SUBSCRIBERLISTENER_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/Subscriber_T.cpp b/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp
index ee5b4343111..deaf7cc3028 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Subscriber_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Subscriber_T.cpp
@@ -1,18 +1,18 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/Subscriber_T.h"
-#include "dds4ccm/impl/ndds/SubscriberListener_T.h"
-#include "dds4ccm/impl/ndds/Topic_T.h"
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.h"
-#include "dds4ccm/impl/ndds/DataReader_T.h"
-#include "dds4ccm/impl/DDSDataReaderListener_T.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/Utils.h"
-
-#include "convertors/InstanceHandle_t.h"
-#include "convertors/DataReaderQos.h"
-#include "convertors/SubscriberQos.h"
-#include "convertors/TopicQos.h"
+#include "Subscriber_T.h"
+#include "SubscriberListener_T.h"
+#include "Topic_T.h"
+#include "ContentFilteredTopic_T.h"
+#include "DataReader_T.h"
+#include "DDSDataReaderListener_T.h"
+#include "Utils.h"
+#include "StatusCondition.h"
+
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/DataReaderQos.h"
+#include "ndds/SubscriberQos.h"
+#include "ndds/TopicQos.h"
 
 #include "dds4ccm/idl/dds4ccm_BaseC.h"
 
@@ -22,51 +22,51 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::DDS_Subscriber_T");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::CCM_DDS_Subscriber_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::~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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::~DDS_Subscriber_T");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::~CCM_DDS_Subscriber_T");
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval;
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       if (sc)
         {
           ACE_NEW_THROW_EX (retval,
-                            DDS_StatusCondition_i (sc),
+                            CCM_DDS_StatusCondition_i (sc),
                             ::CORBA::NO_MEMORY ());
         }
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
       ::DDS_InstanceHandle_t const rtihandle = this->impl ()->get_instance_handle ();
       ::DDS::InstanceHandle_t handle;
@@ -74,9 +74,9 @@ namespace CIAO
       return handle;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::create_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
                   DDSContentFilteredTopic * topic,
                   DDSDataReaderListener * ccm_dds_drl,
                   ::DDS::StatusMask mask,
@@ -90,9 +90,9 @@ namespace CIAO
                                                mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::create_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader (
                   DDSTopic * topic,
                   DDSDataReaderListener * ccm_dds_drl,
                   ::DDS::StatusMask mask,
@@ -106,9 +106,10 @@ namespace CIAO
                                                mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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,
@@ -121,10 +122,12 @@ namespace CIAO
                                                             ccm_dds_drl,
                                                             mask);
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+#if defined (CIAO_DDS4CCM_NDDS) && (CIAO_DDS4CCM_NDDS==1)
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSDataReader *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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,
@@ -137,16 +140,17 @@ namespace CIAO
                                                             ccm_dds_drl,
                                                             mask);
     }
+#endif
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::create_datareader");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader");
       ::DDS::DataReader_var retval;
       DDSDataReaderListener *ccm_dds_drl = 0;
       if (! ::CORBA::is_nil (a_listener))
@@ -166,7 +170,7 @@ namespace CIAO
           if (!cf_topic)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                          "DDS_Subscriber_T<DDS_TYPE, "
+                          "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                           "VENDOR_TYPE>::create_datareader - Error: Unable to "
                           "cast provided topic to one of its servant.\n"));
               delete ccm_dds_drl;
@@ -186,8 +190,8 @@ namespace CIAO
 
       if (!ccm_dds_dr)
         {
-          DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO "DDS_Subscriber_T"
-                       "<DDS_TYPE, VENDOR_TYPE>::create_datareader - "
+          DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO "CCM_DDS_Subscriber_T"
+                       "<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::create_datareader - "
                        "Error: RTI Topic returned a nil datareader.\n"));
           delete ccm_dds_drl;
           return ::DDS::DataReader::_nil ();
@@ -195,7 +199,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_datareader - "
                         "Successfully created datareader.\n"));
         }
@@ -207,16 +211,16 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_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))
         {
@@ -235,7 +239,7 @@ namespace CIAO
           if (!cf_topic)
             {
               DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                            "DDS_Subscriber_T<DDS_TYPE, "
+                            "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"));
@@ -263,7 +267,7 @@ namespace CIAO
       if (!ccm_dds_dr)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "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;
@@ -272,7 +276,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::create_datareader_with_profile - "
                         "Successfully created datareader with profile <%C#%C>.\n",
                         library_name,
@@ -289,23 +293,23 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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 (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datareader -Unable to cast "
                         "provided object reference to servant.\n"));
           return ::DDS::RETCODE_BAD_PARAMETER;
         }
 
       DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_CAST_SUCCESSFUL, (LM_TRACE, DDS4CCM_INFO
-                    "DDS_Subscriber_T<DDS_TYPE, "
+                    "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                     "VENDOR_TYPE>::delete_datareader - "
                     "Successfully casted provided object reference "
                     "to servant.\n"));
@@ -315,7 +319,7 @@ namespace CIAO
       if (retval != DDS_RETCODE_OK)
         {
           DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datareader - "
                         "Error: Returned non-ok error code %C\n",
                         translate_retcode (retval)));
@@ -323,7 +327,7 @@ namespace CIAO
       else
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::delete_datareader - "
                         "Datareader successfully  deleted\n"));
         }
@@ -331,16 +335,16 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DataReader_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::lookup_datareader (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::lookup_datareader (
       const char * impl_name)
     {
       ::DDS::DataReader_var retval;
@@ -354,15 +358,15 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
       ::DDSDataReaderSeq dds_readers;
 
       ::DDS_ReturnCode_t retcode =
@@ -385,43 +389,43 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (
       const ::DDS::SubscriberQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos");
       ::DDS_SubscriberQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl ()->get_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (
       ::DDS::SubscriberQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos");
       ::DDS_SubscriberQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl ()->get_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
       // Delete the previously set listener
       DDSSubscriberListener *listener = this->impl ()->get_listener ();
@@ -437,11 +441,11 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::SubscriberListener_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_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 =
@@ -449,7 +453,7 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Subscriber_T<DDS_TYPE, "
+                        "CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, "
                         "VENDOR_TYPE>::get_listener - "
                         "DDS returned a NIL listener.\n"));
           return ::DDS::SubscriberListener::_nil ();
@@ -457,23 +461,23 @@ namespace CIAO
       return list_proxy->get_subscriber_listener ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_participant (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval;
       DDSDomainParticipant* p = this->impl ()->get_participant ();
@@ -486,36 +490,36 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_default_datareader_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datareader_qos (
       const ::DDS::DataReaderQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::set_default_datareader_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_default_datareader_qos");
       ::DDS_DataReaderQos ccm_dds_qos;
       ccm_dds_qos <<= qos;
       return this->impl ()->set_default_datareader_qos (ccm_dds_qos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_default_datareader_qos (
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datareader_qos (
       ::DDS::DataReaderQos & qos)
     {
-      DDS4CCM_TRACE ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_default_datareader_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_default_datareader_qos");
       ::DDS_DataReaderQos ccm_dds_qos;
       ::DDS::ReturnCode_t retcode = this->impl ()->get_default_datareader_qos (ccm_dds_qos);
       qos <<= ccm_dds_qos;
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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 ("DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
+      DDS4CCM_TRACE ("CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::copy_from_topic_qos");
       ::DDS_DataReaderQos ccm_dds_qos;
       ::DDS_TopicQos ccm_dds_topic_qos;
 
@@ -528,23 +532,23 @@ namespace CIAO
       return retcode;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSSubscriber *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
+    CCM_DDS_Subscriber_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSSubscriber *
-    DDS_Subscriber_T<DDS_TYPE, VENDOR_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/ndds/Subscriber_T.h b/CIAO/connectors/dds4ccm/impl/Subscriber_T.h
index 2206b56c75d..187e7ed0295 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Subscriber_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Subscriber_T.h
@@ -15,50 +15,61 @@
 #include "dds4ccm/idl/dds_rtf2_dcpsC.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
-#include "dds4ccm/impl/ndds/DataReader_T.h"
-
 #include "tao/LocalObject.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::Subscriber DDSSubscriber;
+typedef ::DDS::DataReaderListener DDSDataReaderListener;
+typedef ::DDS::DataReader DDSDataReader;
+typedef ::DDS::ContentFilteredTopic DDSContentFilteredTopic;
+typedef ::DDS::Topic DDSTopic;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DataReaderListener_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DataReaderListener_T;
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class DataReader_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_Topic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_ContentFilteredTopic_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_ContentFilteredTopic_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     class CCM_DDS_SubscriberListener_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipant_T;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DomainParticipant_T;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Subscriber_T :
-      public virtual ::DDS::Subscriber,
+    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, VENDOR_TYPE> DataReaderListener_type;
-    typedef DDS_Topic_T<DDS_TYPE, VENDOR_TYPE> Topic_type;
-    typedef DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE> ContentFilteredTopic_type;
-    typedef DataReader_T<DDS_TYPE, VENDOR_TYPE> DataReader_type;
-    typedef CCM_DDS_SubscriberListener_T<DDS_TYPE, VENDOR_TYPE> SubscriberListener_type;
-    typedef DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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
-      DDS_Subscriber_T (DDSSubscriber * sub);
+      CCM_DDS_Subscriber_T (DDSSubscriber * sub);
 
       /// Destructor
-      virtual ~DDS_Subscriber_T (void);
+      virtual ~CCM_DDS_Subscriber_T (void);
 
       virtual ::DDS::ReturnCode_t enable (void);
 
@@ -74,6 +85,7 @@ namespace CIAO
         ::DDS::DataReaderListener_ptr a_listener,
         ::DDS::StatusMask mask);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       virtual ::DDS::DataReader_ptr
       create_datareader_with_profile (
         ::DDS::TopicDescription_ptr a_topic,
@@ -81,6 +93,7 @@ namespace CIAO
         const char *profile_name,
         ::DDS::DataReaderListener_ptr a_listener,
         ::DDS::StatusMask mask);
+#endif
 
       virtual ::DDS::ReturnCode_t
       delete_datareader (::DDS::DataReader_ptr a_datareader);
@@ -151,6 +164,7 @@ namespace CIAO
         ::DDS::StatusMask mask,
          const ::DDS::DataReaderQos & qos);
 
+#if (CIAO_DDS4CCM_NDDS==1)
       DDSDataReader *
       create_datareader_with_profile (
         DDSContentFilteredTopic * topic,
@@ -158,7 +172,9 @@ namespace CIAO
         const char *profile_name,
         DDSDataReaderListener * ccm_dds_drl,
         ::DDS::StatusMask mask);
+#endif
 
+#if (CIAO_DDS4CCM_NDDS==1)
       DDSDataReader *
       create_datareader_with_profile (
         DDSTopic * topic,
@@ -166,10 +182,11 @@ namespace CIAO
         const char *profile_name,
         DDSDataReaderListener * ccm_dds_drl,
         ::DDS::StatusMask mask);
+#endif
     };
   }
 }
 
-#include "dds4ccm/impl/ndds/Subscriber_T.cpp"
+#include "dds4ccm/impl/Subscriber_T.cpp"
 
 #endif /* SUBSCRIBER_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp
new file mode 100644
index 00000000000..d05d60609cf
--- /dev/null
+++ b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.cpp
@@ -0,0 +1,79 @@
+// $Id$
+
+#include "TopicDescription_T.h"
+#include "DomainParticipant_T.h"
+
+#include "dds4ccm/idl/dds4ccm_BaseC.h"
+#include "dds4ccm/impl/Log_Macros.h"
+
+namespace CIAO
+{
+  namespace DDS4CCM
+  {
+    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, 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, DDS4CCM_Vendor VENDOR_TYPE>
+    char *
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
+    {
+      return CORBA::string_dup (this->impl ()->get_type_name ());
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    char *
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
+    {
+      return CORBA::string_dup (this->impl ()->get_name ());
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    ::DDS::DomainParticipant_ptr
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
+    {
+      ::DDS::DomainParticipant_var retval;
+      DDSDomainParticipant* p = this->impl ()->get_participant ();
+      if (p)
+        {
+          ACE_NEW_THROW_EX (retval,
+                            DomainParticipant_type (p),
+                            ::CORBA::NO_MEMORY ());
+        }
+      return retval._retn ();
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    DDSTopicDescription *
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
+    {
+      return this->impl_;
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    void
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_impl (DDSTopicDescription * rc)
+    {
+      this->impl_ = rc;
+    }
+
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    DDSTopicDescription *
+    CCM_DDS_TopicDescription_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::impl (void)
+    {
+      if (!this->impl_)
+        {
+          throw ::CORBA::BAD_INV_ORDER ();
+        }
+      return this->impl_;
+    }
+  }
+}
+
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/TopicDescription_T.h b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h
index 6b922128199..2b0ba7f6079 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/TopicDescription_T.h
+++ b/CIAO/connectors/dds4ccm/impl/TopicDescription_T.h
@@ -15,28 +15,34 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
+#endif
+
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::TopicDescription DDSTopicDescription;
+#endif
 
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_DomainParticipant;
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DomainParticipant;
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_TopicDescription_T :
-      public virtual ::DDS::TopicDescription,
+    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 DDS_DomainParticipant<DDS_TYPE, VENDOR_TYPE> DomainParticipant_type;
+    typedef CCM_DDS_DomainParticipant<DDS_TYPE, CCM_TYPE, VENDOR_TYPE> DomainParticipant_type;
 
     public:
       /// Constructor
-      DDS_TopicDescription_T (DDSTopicDescription * rc);
+      CCM_DDS_TopicDescription_T (DDSTopicDescription * rc);
 
       /// Destructor
-      virtual ~DDS_TopicDescription_T (void);
+      virtual ~CCM_DDS_TopicDescription_T (void);
 
       virtual char * get_type_name (void);
 
@@ -56,6 +62,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/TopicDescription_T.cpp"
+#include "dds4ccm/impl/TopicDescription_T.cpp"
 
 #endif /* TOPICDESCRIPTION_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp b/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
index 24dae80f59e..308eb9639e4 100644
--- a/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/TopicListener_T.cpp
@@ -1,7 +1,7 @@
 // $Id$
 #include "dds4ccm/impl/Utils.h"
 
-#include "dds4ccm/impl/ndds/Topic_T.h"
+#include "dds4ccm/impl/Topic_T.h"
 #include "dds4ccm/impl/DDSCallbackStatusHandler.h"
 #include "dds4ccm/impl/Log_Macros.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/Topic_T.cpp b/CIAO/connectors/dds4ccm/impl/Topic_T.cpp
index d2f39ef3baf..6b527bda9a0 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Topic_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Topic_T.cpp
@@ -1,13 +1,13 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/Topic_T.h"
-#include "dds4ccm/impl/ndds/ContentFilteredTopic_T.h"
-#include "dds4ccm/impl/ndds/StatusCondition.h"
-#include "dds4ccm/impl/DDSTopicListener_T.h"
+#include "Topic_T.h"
+#include "ContentFilteredTopic_T.h"
+#include "StatusCondition.h"
+#include "DDSTopicListener_T.h"
 
-#include "convertors/InstanceHandle_t.h"
-#include "convertors/InconsistentTopicStatus.h"
-#include "convertors/TopicQos.h"
+#include "ndds/InstanceHandle_t.h"
+#include "ndds/InconsistentTopicStatus.h"
+#include "ndds/TopicQos.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
@@ -16,29 +16,29 @@ namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::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, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::~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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::TopicQos &qos)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_qos (const ::DDS::TopicQos &qos)
     {
       ::DDS_TopicQos ddsqos;
       ddsqos <<= qos;
       return this->impl ()->set_qos (ddsqos);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_qos (::DDS::TopicQos &qos)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_qos (::DDS::TopicQos &qos)
     {
       ::DDS_TopicQos ddsqos;
       ::DDS_ReturnCode_t const retval = this->impl ()->get_qos (ddsqos);
@@ -46,13 +46,13 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_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 ("DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::set_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::set_listener");
 
       // Delete the previously set listener
       DDSTopicListener *listener = this->impl ()->get_listener ();
@@ -68,11 +68,11 @@ namespace CIAO
       return this->impl ()->set_listener (ccm_dds_impl_list, mask);
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::TopicListener_ptr
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_listener (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener (void)
     {
-      DDS4CCM_TRACE ("DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_listener");
+      DDS4CCM_TRACE ("CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_listener");
 
       DDSTopicListener *ccm_dds_topic_list = this->impl ()->get_listener ();
       TopicListener_type * list_proxy =
@@ -80,16 +80,16 @@ namespace CIAO
       if (!list_proxy)
         {
           DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
-                        "DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::"
+                        "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 ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_inconsistent_topic_status (
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_inconsistent_topic_status (
       ::DDS::InconsistentTopicStatus & a_status)
     {
       DDS_InconsistentTopicStatus ddsstatus;
@@ -99,35 +99,35 @@ namespace CIAO
       return retval;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::ReturnCode_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::enable (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::enable (void)
     {
       return this->impl ()->enable ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusCondition_ptr
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_statuscondition (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_statuscondition (void)
     {
       ::DDS::StatusCondition_var retval;
       DDSStatusCondition* sc = this->impl ()->get_statuscondition ();
       ACE_NEW_THROW_EX (retval,
-                        DDS_StatusCondition_i (sc),
+                        CCM_DDS_StatusCondition_i (sc),
                         ::CORBA::NO_MEMORY ());
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::StatusMask
-    DDS_Topic_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::InstanceHandle_t
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_instance_handle (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_instance_handle (void)
     {
       ::DDS_InstanceHandle_t const rtihandle =
         this->impl ()->get_instance_handle ();
@@ -136,23 +136,23 @@ namespace CIAO
       return handle;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_type_name (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_type_name (void)
     {
       return CORBA::string_dup (this->impl ()->get_type_name ());
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     char *
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_name (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_name (void)
     {
       return CORBA::string_dup (this->impl ()->get_name ());
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     ::DDS::DomainParticipant_ptr
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_participant (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_participant (void)
     {
       ::DDS::DomainParticipant_var retval;
       DDSDomainParticipant * p = this->impl ()->get_participant ();
@@ -165,23 +165,23 @@ namespace CIAO
       return retval._retn ();
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopic *
-    DDS_Topic_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
+    CCM_DDS_Topic_T<DDS_TYPE, CCM_TYPE, VENDOR_TYPE>::get_impl (void)
     {
       return this->impl_;
     }
 
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     void
-    DDS_Topic_T<DDS_TYPE, VENDOR_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, DDS4CCM_Vendor VENDOR_TYPE>
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
     DDSTopic *
-    DDS_Topic_T<DDS_TYPE, VENDOR_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/ndds/Topic_T.h b/CIAO/connectors/dds4ccm/impl/Topic_T.h
index 2eb680c842f..d42b0961dfd 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/Topic_T.h
+++ b/CIAO/connectors/dds4ccm/impl/Topic_T.h
@@ -7,32 +7,38 @@
  * Wrapper facade for NDDS.
  */
 
-#ifndef NDDS_TOPIC_H
-#define NDDS_TOPIC_H
+#ifndef CIAO_NDDS_TOPIC_H
+#define CIAO_NDDS_TOPIC_H
 
-#include "dds4ccm/impl/ndds/DomainParticipant_T.h"
-#include "dds4ccm/impl/DDSTopicListener_T.h"
+#include "DomainParticipant_T.h"
 
 #include "tao/LocalObject.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::Topic DDSTopic;
+#endif
+
 namespace CIAO
 {
   namespace DDS4CCM
   {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    class DDS_Topic_T :
-      public virtual ::DDS::Topic,
+    template <typename DDS_TYPE, typename CCM_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
+    class CCM_DDS_DomainParticipant_T;
+
+    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, VENDOR_TYPE> TopicListener_type;
-    typedef DDS_DomainParticipant_T<DDS_TYPE, VENDOR_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
-      DDS_Topic_T (DDSTopic* topic);
+      CCM_DDS_Topic_T (DDSTopic* topic);
 
       /// Destructor
-      virtual ~DDS_Topic_T (void);
+      virtual ~CCM_DDS_Topic_T (void);
 
       virtual ::DDS::ReturnCode_t set_qos (const ::DDS::TopicQos & qos);
 
@@ -73,6 +79,6 @@ namespace CIAO
   }
 }
 
-#include "dds4ccm/impl/ndds/Topic_T.cpp"
+#include "dds4ccm/impl/Topic_T.cpp"
 
 #endif
diff --git a/CIAO/connectors/dds4ccm/impl/Updater_T.cpp b/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
index 812c6eed0bf..1f3abc9ba09 100644
--- a/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Updater_T.cpp
@@ -1,6 +1,6 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "dds4ccm/impl/DataWriter_T.h"
 #include "dds4ccm/impl/Utils.h"
 #include "dds4ccm/impl/Coherent_Changes_Guard.h"
 #include "dds4ccm/impl/Log_Macros.h"
diff --git a/CIAO/connectors/dds4ccm/impl/Writer_T.cpp b/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
index cdce59f8a68..e0c8e10735c 100644
--- a/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
+++ b/CIAO/connectors/dds4ccm/impl/Writer_T.cpp
@@ -1,10 +1,10 @@
 // $Id$
 
-#include "dds4ccm/impl/ndds/DataWriter_T.h"
+#include "dds4ccm/impl/DataWriter_T.h"
 #include "dds4ccm/impl/Utils.h"
 #include "dds4ccm/impl/Coherent_Changes_Guard.h"
 
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 
 #include "dds4ccm/impl/Log_Macros.h"
 
diff --git a/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h b/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
index dafc00bba32..b4199af9f11 100644
--- a/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
+++ b/CIAO/connectors/dds4ccm/impl/dds4ccm_conf.h
@@ -29,8 +29,7 @@
 
 enum DDS4CCM_Vendor
 {
-  DDS4CCM_NDDS,
-  DDS4CCM_OPENDDS
+  DDS4CCM_NDDS
 };
 
 #endif /* DDS4CCM_CONF_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/dds4ccm_impl.mpc b/CIAO/connectors/dds4ccm/impl/dds4ccm_impl.mpc
index c1c7ad41321..d433a9e76b4 100644
--- a/CIAO/connectors/dds4ccm/impl/dds4ccm_impl.mpc
+++ b/CIAO/connectors/dds4ccm/impl/dds4ccm_impl.mpc
@@ -14,9 +14,12 @@ project(CIAO_DDS4CCM_DDS_Impl) : install, dds4ccm_skel, dds4ccm_lem_stub, taolib
   }
 
   Source_Files {
+    DataReader.cpp
+    DataWriter.cpp
     Coherent_Changes_Guard.cpp
-    DDSDomainParticipantListener.cpp
+    DomainParticipantListener.cpp
     ContentFilterSetting.cpp
+    StatusCondition.cpp
     Utils.cpp
     DDSCallbackStatusHandler.cpp
     DomainParticipantManager.cpp
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/BuiltinTopicKey_t.h b/CIAO/connectors/dds4ccm/impl/ndds/BuiltinTopicKey_t.h
index a370de5d178..eca7d9a4dd9 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/BuiltinTopicKey_t.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/BuiltinTopicKey_t.h
@@ -10,6 +10,7 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::BuiltinTopicKey_t &ddsbuiltintopickey, const ::DDS_BuiltinTopicKey_t & builtintopickey)
 {
@@ -22,4 +23,6 @@ operator<<= (::DDS_BuiltinTopicKey_t &ddsbuiltintopickey, const ::DDS::BuiltinTo
   ACE_OS::memcpy (ddsbuiltintopickey.value, builtintopickey.value, sizeof (builtintopickey.value));
 }
 
+#endif
+
 #endif /* BUILTINTOPICKEY_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/ContentFilteredTopic_T.cpp b/CIAO/connectors/dds4ccm/impl/ndds/ContentFilteredTopic_T.cpp
deleted file mode 100644
index a67b09ca15f..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/ContentFilteredTopic_T.cpp
+++ /dev/null
@@ -1,125 +0,0 @@
-// $Id$
-
-#include "ContentFilteredTopic_T.h"
-#include "Topic_T.h"
-
-#include "convertors/StringSeq.h"
-
-#include "dds4ccm/impl/Log_Macros.h"
-#include "dds4ccm/impl/dds4ccm_conf.h"
-
-namespace CIAO
-{
-  namespace DDS4CCM
-  {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::DDS_ContentFilteredTopic_T (
-        DDSContentFilteredTopic * dw)
-      : impl_ (dw)
-    {
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::~DDS_ContentFilteredTopic_T (void)
-    {
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    char *
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_filter_expression (void)
-    {
-      DDS4CCM_TRACE ("DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_filter_expression");
-      return CORBA::string_dup (this->impl ()->get_filter_expression ());
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::ReturnCode_t
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_expression_parameters (
-      ::DDS::StringSeq & expression_parameters)
-    {
-      DDS4CCM_TRACE ("DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_expression_parameters");
-      DDS_StringSeq parameters;
-      ::DDS::ReturnCode_t retval =
-        this->impl ()->get_expression_parameters (parameters);
-      expression_parameters <<= parameters;
-      return retval;
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::ReturnCode_t
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::set_expression_parameters (
-      const ::DDS::StringSeq & expression_parameters)
-    {
-      DDS4CCM_TRACE ("DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::set_expression_parameters");
-
-      DDS_StringSeq parameters;
-      parameters <<= expression_parameters;
-      return this->impl ()->set_expression_parameters (parameters);
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::Topic_ptr
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_related_topic (void)
-    {
-      DDS4CCM_TRACE ("DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_related_topic");
-
-      ::DDS::Topic_var retval;
-      DDSTopic *topic = this->impl ()->get_related_topic ();
-      ACE_NEW_THROW_EX (retval,
-                        Topic_type (topic),
-                        ::CORBA::NO_MEMORY ());
-      return retval._retn ();
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    char *
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_type_name (void)
-    {
-      return CORBA::string_dup (this->impl ()->get_type_name ());
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    char *
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_name (void)
-    {
-      return CORBA::string_dup (this->impl ()->get_name ());
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::DomainParticipant_ptr
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_participant (void)
-    {
-      ::DDS::DomainParticipant_var retval;
-      DDSDomainParticipant * p = this->impl ()->get_participant ();
-      ACE_NEW_THROW_EX (retval,
-                        DomainParticipant_type (p),
-                        ::CORBA::NO_MEMORY ());
-      return retval._retn ();
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDSContentFilteredTopic *
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
-    {
-      return this->impl_;
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    void
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::set_impl (DDSContentFilteredTopic * dw)
-    {
-      this->impl_ = dw;
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDSContentFilteredTopic *
-    DDS_ContentFilteredTopic_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
-    {
-      if (!this->impl_)
-        {
-          throw ::CORBA::BAD_INV_ORDER ();
-        }
-      return this->impl_;
-    }
-  }
-}
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DataReaderQos.h b/CIAO/connectors/dds4ccm/impl/ndds/DataReaderQos.h
index b2466995a43..8df844a7386 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DataReaderQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DataReaderQos.h
@@ -24,6 +24,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DataReaderQos DDS_DataReaderQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DataReaderQos &ddsqos, const ::DDS_DataReaderQos & qos)
 {
@@ -58,4 +63,6 @@ operator<<= (::DDS_DataReaderQos &ddsqos, const ::DDS::DataReaderQos & qos)
   ddsqos.reader_data_lifecycle <<= qos.reader_data_lifecycle;
 }
 
+#endif
+
 #endif /* DDS4CCM_DATAREADERQOS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DataWriterQos.h b/CIAO/connectors/dds4ccm/impl/ndds/DataWriterQos.h
index 00d55ca563d..28eef81e587 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DataWriterQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DataWriterQos.h
@@ -27,6 +27,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DataWriterQos DDS_DataWriterQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DataWriterQos &ddsqos, const ::DDS_DataWriterQos & qos)
 {
@@ -67,4 +72,6 @@ operator<<= (::DDS_DataWriterQos &ddsqos, const ::DDS::DataWriterQos & qos)
   ddsqos.writer_data_lifecycle <<= qos.writer_data_lifecycle;
 }
 
+#endif
+
 #endif /* DDS4CCM_DATAWRITERQOS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DeadlineQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/DeadlineQosPolicy.h
index 8e572d41b19..59baeba5405 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DeadlineQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DeadlineQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DeadlineQosPolicy DDS_DeadlineQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DeadlineQosPolicy &ddsqos, const ::DDS_DeadlineQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_DeadlineQosPolicy &ddsqos, const ::DDS::DeadlineQosPolicy & q
   ddsqos.period <<= qos.period;
 }
 
+#endif
+
 #endif /* DDS4CCM_DEADLINEQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DestinationOrderQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/DestinationOrderQosPolicy.h
index 46593a6d096..b28d8bedf75 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DestinationOrderQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DestinationOrderQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DestinationOrderQosPolicy DDS_DestinationOrderQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DestinationOrderQosPolicy &ddsqos, const ::DDS_DestinationOrderQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_DestinationOrderQosPolicy &ddsqos, const ::DDS::DestinationOr
   ddsqos.kind = static_cast < ::DDS_DestinationOrderQosPolicyKind> (qos.kind);
 }
 
+#endif
+
 #endif /* DDS4CCM_DESTINATIONORDERQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DomainParticipantFactoryQos.h b/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactoryQos.h
index f36cbfb8e5f..5a392830c03 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DomainParticipantFactoryQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantFactoryQos.h
@@ -16,6 +16,7 @@
 typedef ::DDS::DomainParticipantFactoryQos DDS_DomainParticipantFactoryQos;
 #endif
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DomainParticipantFactoryQos &ddsqos, const ::DDS_DomainParticipantFactoryQos & qos)
 {
@@ -28,4 +29,6 @@ operator<<= (::DDS_DomainParticipantFactoryQos &ddsqos, const ::DDS::DomainParti
   ddsqos.entity_factory <<= qos.entity_factory;
 }
 
+#endif
+
 #endif /* DDS4CCM_DOMAINPARTICIPANTFACTORYQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DomainParticipantQos.h b/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantQos.h
index 12dfd4aa87e..e6f8429ca35 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DomainParticipantQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DomainParticipantQos.h
@@ -14,6 +14,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DomainParticipantQos DDS_DomainParticipantQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DomainParticipantQos &ddsqos, const ::DDS_DomainParticipantQos & qos)
 {
@@ -28,4 +33,6 @@ operator<<= (::DDS_DomainParticipantQos &ddsqos, const ::DDS::DomainParticipantQ
   ddsqos.entity_factory <<= qos.entity_factory;
 }
 
+#endif
+
 #endif /* DDS4CCM_DOMAINPARTICIPANTQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DurabilityQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/DurabilityQosPolicy.h
index 44e07c1e4f3..08ad411e188 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DurabilityQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DurabilityQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DurabilityQosPolicy DDS_DurabilityQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DurabilityQosPolicy &ddsqos, const ::DDS_DurabilityQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_DurabilityQosPolicy &ddsqos, const ::DDS::DurabilityQosPolicy
   ddsqos.kind = static_cast < ::DDS_DurabilityQosPolicyKind> (qos.kind);
 }
 
+#endif
+
 #endif /* DDS4CCM_DURABILITYQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DurabilityServiceQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/DurabilityServiceQosPolicy.h
index 21517eaae2b..9686b01e59d 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/DurabilityServiceQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/DurabilityServiceQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::DurabilityServiceQosPolicy DDS_DurabilityServiceQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::DurabilityServiceQosPolicy &ddsqos, const ::DDS_DurabilityServiceQosPolicy & qos)
 {
@@ -34,4 +39,6 @@ operator<<= (::DDS_DurabilityServiceQosPolicy &ddsqos, const ::DDS::DurabilitySe
   ddsqos.max_samples_per_instance = qos.max_samples_per_instance;
 }
 
+#endif
+
 #endif /* DDS4CCM_DURABILITYSERVICEQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/Duration_t.h b/CIAO/connectors/dds4ccm/impl/ndds/Duration_t.h
index 37ae28c7118..f146e716097 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/Duration_t.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/Duration_t.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::Duration_t DDS_Duration_t;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::Duration_t &ddsduration, const ::DDS_Duration_t & duration)
 {
@@ -26,5 +31,7 @@ operator<<= (::DDS_Duration_t &ddsduration, const ::DDS::Duration_t & duration)
   ddsduration.nanosec = duration.nanosec;
 }
 
+#endif
+
 #endif /* DDS4CCM_DURATION_T_H_ */
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/EntityFactoryQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/EntityFactoryQosPolicy.h
index 558d19eb28b..356de511292 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/EntityFactoryQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/EntityFactoryQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::EntityFactoryQosPolicy DDS_EntityFactoryQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::EntityFactoryQosPolicy &ddsqos, const ::DDS_EntityFactoryQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_EntityFactoryQosPolicy &ddsqos, const ::DDS::EntityFactoryQos
   ddsqos.autoenable_created_entities = qos.autoenable_created_entities;
 }
 
+#endif
+
 #endif /* DDS4CCM_ENTITYFACTORYQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/GroupDataQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/GroupDataQosPolicy.h
index e8820ba0d8c..c8c63445f29 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/GroupDataQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/GroupDataQosPolicy.h
@@ -12,6 +12,12 @@
 #include "OctetSeq.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::GroupDataQosPolicy DDS_GroupDataQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
+
 inline void
 operator<<= (::DDS::GroupDataQosPolicy &ddsqos, const ::DDS_GroupDataQosPolicy & qos)
 {
@@ -24,4 +30,6 @@ operator<<= (::DDS_GroupDataQosPolicy &ddsqos, const ::DDS::GroupDataQosPolicy &
   ddsqos.value <<= qos.value;
 }
 
+#endif
+
 #endif /* DDS4CCM_GROUPDATAQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/HistoryQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/HistoryQosPolicy.h
index b77fcafda79..d2140f4ca63 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/HistoryQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/HistoryQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::HistoryQosPolicy DDS_HistoryQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::HistoryQosPolicy &ddsqos, const ::DDS_HistoryQosPolicy & qos)
 {
@@ -25,4 +30,6 @@ operator<<= (::DDS_HistoryQosPolicy &ddsqos, const ::DDS::HistoryQosPolicy & qos
   ddsqos.depth = qos.depth;
 }
 
+#endif
+
 #endif /* DDS4CCM_HISTORYQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InconsistentTopicStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/InconsistentTopicStatus.h
index 4a710966e13..6946874f57c 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InconsistentTopicStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/InconsistentTopicStatus.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::InconsistentTopicStatus DDS_InconsistentTopicStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::InconsistentTopicStatus &ddsstatus, const ::DDS_InconsistentTopicStatus & status)
 {
@@ -26,4 +31,6 @@ operator<<= (::DDS_InconsistentTopicStatus &ddsstatus, const ::DDS::Inconsistent
   ddsstatus.total_count_change = status.total_count_change;
 }
 
+#endif
+
 #endif /* DDS4CCM_INCONSISTENTTOPICSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InstanceHandleSeq.h b/CIAO/connectors/dds4ccm/impl/ndds/InstanceHandleSeq.h
index 69e269b8a43..6a95c92a610 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InstanceHandleSeq.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/InstanceHandleSeq.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::InstanceHandleSeq DDS_InstanceHandleSeq;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 template <typename corbaseq, typename ddsseq>
 void convert_dds_to_corba_sequence(corbaseq & target, const ddsseq& source) {
   target.length (source.length ());
@@ -38,4 +43,6 @@ operator<<= (::DDS_InstanceHandleSeq &ddsinstancehandleseqseq, const ::DDS::Inst
     }
 }
 
+#endif
+
 #endif /* DDS4CCM_INSTANCEHANDLESEQ_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InstanceHandle_t.h b/CIAO/connectors/dds4ccm/impl/ndds/InstanceHandle_t.h
index e745001b702..f4b5af836d2 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/InstanceHandle_t.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/InstanceHandle_t.h
@@ -12,10 +12,18 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 #include "ndds/ndds_cpp.h"
 #define DDS_INSTANCE_HANDLE_T_IN const ::DDS::InstanceHandle_t &
 #define DDS_INSTANCE_HANDLE_T_RETN ::DDS::InstanceHandle_t
+#endif
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+#define DDS_INSTANCE_HANDLE_T_IN ::DDS::InstanceHandle_t
+#define DDS_INSTANCE_HANDLE_T_RETN ::DDS::InstanceHandle_t
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::InstanceHandle_t &ddsinstancehandle, const ::DDS_InstanceHandle_t & instancehandle)
 {
@@ -79,4 +87,6 @@ operator!= (const ::DDS::InstanceHandle_t & ccm_instancehandle, const DDS_Instan
          ccm_instancehandle.isValid != static_cast<CORBA::ULong>(dds_instancehandle.isValid) ||
          ACE_OS::memcmp (ccm_instancehandle.value, dds_instancehandle.keyHash.value, sizeof (ccm_instancehandle.value)) != 0;
 }
+#endif
+
 #endif /* DDS4CCM_INSTANCEHANDLE_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LatencyBudgetQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/LatencyBudgetQosPolicy.h
index dd066de6b79..27900434e79 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LatencyBudgetQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/LatencyBudgetQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::LatencyBudgetQosPolicy DDS_LatencyBudgetQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::LatencyBudgetQosPolicy &ddsqos, const ::DDS_LatencyBudgetQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_LatencyBudgetQosPolicy &ddsqos, const ::DDS::LatencyBudgetQos
   ddsqos.duration <<= qos.duration;
 }
 
+#endif
+
 #endif /* DDS4CCM_LATENCYBUDGETQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LifespanQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/LifespanQosPolicy.h
index 6e632e5fea1..53220c3b745 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LifespanQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/LifespanQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::LifespanQosPolicy DDS_LifespanQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::LifespanQosPolicy &ddsqos, const ::DDS_LifespanQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_LifespanQosPolicy &ddsqos, const ::DDS::LifespanQosPolicy & q
   ddsqos.duration <<= qos.duration;
 }
 
+#endif
+
 #endif /* DDS4CCM_LIFESPANQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessChangedStatus.h
index e00582271fd..a588bb4cf31 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessChangedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessChangedStatus.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::LivelinessChangedStatus DDS_LivelinessChangedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::LivelinessChangedStatus &ddsstatus, const ::DDS_LivelinessChangedStatus & status)
 {
@@ -33,4 +38,6 @@ operator<<= (::DDS_LivelinessChangedStatus &ddsstatus, const ::DDS::LivelinessCh
   ddsstatus.last_publication_handle <<= status.last_publication_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_LIVELINESSCHANGEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessLostStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessLostStatus.h
index 378b0eab72b..dff10ab7ab3 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessLostStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessLostStatus.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::LivelinessLostStatus DDS_LivelinessLostStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::LivelinessLostStatus &ddsstatus, const ::DDS_LivelinessLostStatus & status)
 {
@@ -26,4 +31,6 @@ operator<<= (::DDS_LivelinessLostStatus &ddsstatus, const ::DDS::LivelinessLostS
   ddsstatus.total_count_change = status.total_count_change;
 }
 
+#endif
+
 #endif /* DDS4CCM_LIVELINESSLOSTSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessQosPolicy.h
index 147f8c23e69..18b56dae8cf 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/LivelinessQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/LivelinessQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::LivelinessQosPolicy DDS_LivelinessQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::LivelinessQosPolicy &ddsqos, const ::DDS_LivelinessQosPolicy & qos)
 {
@@ -26,4 +31,6 @@ operator<<= (::DDS_LivelinessQosPolicy &ddsqos, const ::DDS::LivelinessQosPolicy
   ddsqos.lease_duration <<= qos.lease_duration;
 }
 
+#endif
+
 #endif /* DDS4CCM_LIVELINESSQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OctetSeq.h b/CIAO/connectors/dds4ccm/impl/ndds/OctetSeq.h
index ed0cc97a018..ed0cc97a018 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OctetSeq.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/OctetSeq.h
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OfferedDeadlineMissedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/OfferedDeadlineMissedStatus.h
index 36e38b840ad..164d6a571c4 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OfferedDeadlineMissedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/OfferedDeadlineMissedStatus.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::OfferedDeadlineMissedStatus DDS_OfferedDeadlineMissedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::OfferedDeadlineMissedStatus &ddsstatus, const ::DDS_OfferedDeadlineMissedStatus & status)
 {
@@ -29,4 +34,6 @@ operator<<= (::DDS_OfferedDeadlineMissedStatus &ddsstatus, const ::DDS::OfferedD
   ddsstatus.last_instance_handle <<= status.last_instance_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_OFFEREDDEADLINEMISSEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OfferedIncompatibleQosStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/OfferedIncompatibleQosStatus.h
index 2539342d487..9b6391a747b 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OfferedIncompatibleQosStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/OfferedIncompatibleQosStatus.h
@@ -13,6 +13,11 @@
 #include "QosPolicyCountSeq.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::OfferedIncompatibleQosStatus DDS_OfferedIncompatibleQosStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::OfferedIncompatibleQosStatus &ddsstatus, const ::DDS_OfferedIncompatibleQosStatus & status)
 {
@@ -31,4 +36,6 @@ operator<<= (::DDS_OfferedIncompatibleQosStatus &ddsstatus, const ::DDS::Offered
   ddsstatus.policies <<= status.policies;
 }
 
+#endif
+
 #endif /* DDS4CCM_OFFEREDINCOMPATIBLEQOSSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OwnershipQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/OwnershipQosPolicy.h
index 7678511c2b2..eec42c30ed1 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OwnershipQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/OwnershipQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::OwnershipQosPolicy DDS_OwnershipQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::OwnershipQosPolicy &ddsqos, const ::DDS_OwnershipQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_OwnershipQosPolicy &ddsqos, const ::DDS::OwnershipQosPolicy &
   ddsqos.kind = static_cast < ::DDS_OwnershipQosPolicyKind> (qos.kind);
 }
 
+#endif
+
 #endif /* DDS4CCM_OWNERSHIPQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OwnershipStrengthQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/OwnershipStrengthQosPolicy.h
index de359d74740..77401f1d9e2 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/OwnershipStrengthQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/OwnershipStrengthQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::OwnershipStrengthQosPolicy DDS_OwnershipStrengthQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::OwnershipStrengthQosPolicy &ddsqos, const ::DDS_OwnershipStrengthQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_OwnershipStrengthQosPolicy &ddsqos, const ::DDS::OwnershipStr
   ddsqos.value = qos.value;
 }
 
+#endif
+
 #endif /* DDS4CCM_OWNERSHIPSTRENGTHQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ParticipantBuiltinTopicData.h b/CIAO/connectors/dds4ccm/impl/ndds/ParticipantBuiltinTopicData.h
index 9b6db3bc50b..67600ad3858 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ParticipantBuiltinTopicData.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ParticipantBuiltinTopicData.h
@@ -13,6 +13,7 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::ParticipantBuiltinTopicData &ddstopicdata, const ::DDS_ParticipantBuiltinTopicData & topicdata)
 {
@@ -27,4 +28,6 @@ operator<<= (::DDS_ParticipantBuiltinTopicData & ddstopicdata, const ::DDS::Part
   ddstopicdata.user_data <<= topicdata.user_data;
 }
 
+#endif
+
 #endif /* PARTICIPANTBUILTINTOPICDATA_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PartitionQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/PartitionQosPolicy.h
index 6788c652faf..0059665c277 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PartitionQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/PartitionQosPolicy.h
@@ -13,6 +13,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::PartitionQosPolicy DDS_PartitionQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::PartitionQosPolicy &ddsqos, const ::DDS_PartitionQosPolicy & qos)
 {
@@ -25,4 +30,6 @@ operator<<= (::DDS_PartitionQosPolicy &ddsqos, const ::DDS::PartitionQosPolicy &
   ddsqos.name <<= qos.name;
 }
 
+#endif
+
 #endif /* DDS4CCM_PARTITIONQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PresentationQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/PresentationQosPolicy.h
index 967102316cb..7d5ab4fc283 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PresentationQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/PresentationQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::PresentationQosPolicy DDS_PresentationQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::PresentationQosPolicy &ddsqos, const ::DDS_PresentationQosPolicy & qos)
 {
@@ -27,4 +32,6 @@ operator<<= (::DDS_PresentationQosPolicy &ddsqos, const ::DDS::PresentationQosPo
   ddsqos.ordered_access = qos.ordered_access;
 }
 
+#endif
+
 #endif /* DDS4CCM_PRESENTATIONQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublicationBuiltinTopicData.h b/CIAO/connectors/dds4ccm/impl/ndds/PublicationBuiltinTopicData.h
index 6190cfb0fa1..ce578f36e82 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublicationBuiltinTopicData.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/PublicationBuiltinTopicData.h
@@ -27,6 +27,7 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::PublicationBuiltinTopicData &ddstopicdata, const ::DDS_PublicationBuiltinTopicData & topicdata)
 {
@@ -76,3 +77,5 @@ operator<<= (::DDS_PublicationBuiltinTopicData & ddstopicdata, const ::DDS::Publ
 }
 
 #endif
+
+#endif
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublicationMatchedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/PublicationMatchedStatus.h
index 2afe9ad25a0..2374f58d2c2 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublicationMatchedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/PublicationMatchedStatus.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::PublicationMatchedStatus DDS_PublicationMatchedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::PublicationMatchedStatus &ddsstatus, const ::DDS_PublicationMatchedStatus & status)
 {
@@ -33,4 +38,6 @@ operator<<= (::DDS_PublicationMatchedStatus &ddsstatus, const ::DDS::Publication
   ddsstatus.last_subscription_handle <<= status.last_subscription_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_PUBLICATIONMATCHEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublisherQos.h b/CIAO/connectors/dds4ccm/impl/ndds/PublisherQos.h
index b9891b2e8c9..6a129795137 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/PublisherQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/PublisherQos.h
@@ -16,6 +16,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::PublisherQos DDS_PublisherQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::PublisherQos &ddsqos, const ::DDS_PublisherQos & qos)
 {
@@ -34,4 +39,6 @@ operator<<= (::DDS_PublisherQos &ddsqos, const ::DDS::PublisherQos & qos)
   ddsqos.entity_factory <<= qos.entity_factory;
 }
 
+#endif
+
 #endif /* DDS4CCM_PUBLISHERQOS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/QosPolicyCountSeq.h b/CIAO/connectors/dds4ccm/impl/ndds/QosPolicyCountSeq.h
index 7c39e3d3e88..5a6224d84a7 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/QosPolicyCountSeq.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/QosPolicyCountSeq.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::QosPolicyCountSeq DDS_QosPolicyCountSeq;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::QosPolicyCountSeq & ddspolicycount, const ::DDS_QosPolicyCountSeq & policycount)
 {
@@ -34,4 +39,6 @@ operator<<= (::DDS_QosPolicyCountSeq & ddspolicycount, const ::DDS::QosPolicyCou
     }
 }
 
+#endif
+
 #endif /* DDS4CCM_QOSPOLICYCOUNTSEQ_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/QueryCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/ndds/QueryCondition_T.cpp
deleted file mode 100644
index 5be7d7310ad..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/QueryCondition_T.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-// $Id$
-
-#include "QueryCondition_T.h"
-#include "dds4ccm/impl/ndds/Subscriber_T.h"
-
-#include "dds4ccm/impl/ndds/convertors/StringSeq.h"
-
-#include "dds4ccm/idl/dds4ccm_BaseC.h"
-
-#include "dds4ccm/impl/Log_Macros.h"
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::DDS_QueryCondition_T (DDSQueryCondition * qc)
-  : impl_ (qc)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::DDS_QueryCondition_T");
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::~DDS_QueryCondition_T (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::~DDS_QueryCondition_T");
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::CORBA::Boolean
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_trigger_value (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_trigger_value");
-
-  return this->impl ()->get_trigger_value ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::SampleStateMask
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_sample_state_mask");
-
-  return this->impl ()->get_sample_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::ViewStateMask
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_view_state_mask");
-
-  return this->impl ()->get_view_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::InstanceStateMask
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_instance_state_mask");
-
-  return this->impl ()->get_instance_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::DataReader_ptr
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_datareader (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_datareader");
-
-  ::DDS::DataReader_var dds_reader;
-  DDSDataReader* reader = this->impl ()->get_datareader ();
-  if (reader)
-    {
-      ACE_NEW_THROW_EX (dds_reader,
-                        DataReader_type (reader),
-                        ::CORBA::NO_MEMORY ());
-    }
-  return dds_reader._retn ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-char *
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_query_expression (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_query_expression");
-
-  return ::CORBA::string_dup (this->impl ()->get_query_expression ());
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::ReturnCode_t
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_query_parameters (
-  ::DDS::StringSeq & query_parameters)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::get_query_parameters");
-
-  DDS_StringSeq parameters;
-  ::DDS::ReturnCode_t const retval =
-    this->impl ()->get_query_parameters (parameters);
-  query_parameters <<= parameters;
-  return retval;
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::ReturnCode_t
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::set_query_parameters (
-  const ::DDS::StringSeq & query_parameters)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_QueryCondition_T::set_query_parameters");
-
-  DDS_StringSeq parameters;
-  parameters <<= query_parameters;
-
-  return this->impl ()->set_query_parameters (parameters);
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-DDSQueryCondition *
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
-{
-  return this->impl_;
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-void
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::set_impl (DDSQueryCondition * dw)
-{
-  this->impl_ = dw;
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-DDSQueryCondition *
-CIAO::DDS4CCM::DDS_QueryCondition_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
-{
-  if (!this->impl_)
-    {
-      throw ::CORBA::BAD_INV_ORDER ();
-    }
-  return this->impl_;
-}
-
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/ReadCondition_T.cpp b/CIAO/connectors/dds4ccm/impl/ndds/ReadCondition_T.cpp
deleted file mode 100644
index 293a0b0d813..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/ReadCondition_T.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-// $Id$
-
-#include "ReadCondition_T.h"
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::DDS_ReadCondition_T (
-  DDSReadCondition * rc)
-  : impl_ (rc)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::DDS_ReadCondition_T");
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::~DDS_ReadCondition_T (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::~DDS_ReadCondition_T");
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::CORBA::Boolean
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_trigger_value (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::get_trigger_value");
-
-  return this->impl ()->get_trigger_value ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::SampleStateMask
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_sample_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::get_sample_state_mask");
-
-  return this->impl ()->get_sample_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::ViewStateMask
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_view_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::get_view_state_mask");
-
-  return this->impl ()->get_view_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::InstanceStateMask
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_instance_state_mask (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::get_instance_state_mask");
-
-  return this->impl ()->get_instance_state_mask ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-::DDS::DataReader_ptr
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_datareader (void)
-{
-  DDS4CCM_TRACE ("CIAO::DDS4CCM::DDS_ReadCondition_T::get_datareader");
-
-  ::DDS::DataReader_var retval;
-  DDSDataReader* rd = this->impl ()->get_datareader ();
-  if (rd)
-    {
-      ACE_NEW_THROW_EX (retval,
-                        DataReader_type (rd),
-                        ::CORBA::NO_MEMORY ());
-    }
-  return retval._retn ();
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-DDSReadCondition *
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
-{
-  return this->impl_;
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-void
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::set_impl (
-  DDSReadCondition * rc)
-{
-  this->impl_ = rc;
-}
-
-template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-DDSReadCondition *
-CIAO::DDS4CCM::DDS_ReadCondition_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
-{
-  if (!this->impl_)
-    {
-      throw ::CORBA::BAD_INV_ORDER ();
-    }
-  return this->impl_;
-}
-
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReaderDataLifecycleQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/ReaderDataLifecycleQosPolicy.h
index 1ae72b3e85f..8d0ab08b72a 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReaderDataLifecycleQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ReaderDataLifecycleQosPolicy.h
@@ -11,6 +11,12 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ReaderDataLifecycleQosPolicy DDS_ReaderDataLifecycleQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
+
 #include "Duration_t.h"
 
 inline void
@@ -27,4 +33,6 @@ operator<<= (::DDS_ReaderDataLifecycleQosPolicy &ddsqos, const ::DDS::ReaderData
   ddsqos.autopurge_disposed_samples_delay <<= qos.autopurge_disposed_samples_delay;
 }
 
+#endif
+
 #endif /* DDS4CCM_READERDATALIFECYCLEQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliabilityQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/ReliabilityQosPolicy.h
index 763f59fd0f1..d4253585857 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliabilityQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ReliabilityQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ReliabilityQosPolicy DDS_ReliabilityQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::ReliabilityQosPolicy &ddsqos, const ::DDS_ReliabilityQosPolicy & qos)
 {
@@ -26,4 +31,6 @@ operator<<= (::DDS_ReliabilityQosPolicy &ddsqos, const ::DDS::ReliabilityQosPoli
   ddsqos.max_blocking_time <<= qos.max_blocking_time;
 }
 
+#endif
+
 #endif /* DDS4CCM_RELIABILITYSQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliableReaderActivityChangedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/ReliableReaderActivityChangedStatus.h
index f57ff870c19..d5611558b9c 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliableReaderActivityChangedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ReliableReaderActivityChangedStatus.h
@@ -9,9 +9,14 @@
 #ifndef DDS4CCM_RELIABLEREADERACTIVITYCHANGEDSTATUS_H
 #define DDS4CCM_RELIABLEREADERACTIVITYCHANGEDSTATUS_H
 
-#include "dds4ccm/impl/ndds/convertors/InstanceHandle_t.h"
+#include "dds4ccm/impl/ndds/InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ReliableReaderActivityChangedStatus DDS_ReliableReaderActivityChangedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::ReliableReaderActivityChangedStatus &ddsstatus, const ::DDS_ReliableReaderActivityChangedStatus & status)
 {
@@ -32,4 +37,6 @@ operator<<= (::DDS_ReliableReaderActivityChangedStatus &ddsstatus, const ::DDS::
   ddsstatus.last_instance_handle <<= status.last_instance_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_RELIABLEREADERACTIVITYCHANGEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliableWriterCacheChangedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/ReliableWriterCacheChangedStatus.h
index e5bef6159cd..31e8653b8be 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ReliableWriterCacheChangedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ReliableWriterCacheChangedStatus.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ReliableWriterCacheChangedStatus DDS_ReliableWriterCacheChangedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::ReliableWriterCacheChangedStatus &ddsstatus, const ::DDS_ReliableWriterCacheChangedStatus & status)
 {
@@ -41,4 +46,6 @@ operator<<= (::DDS_ReliableWriterCacheChangedStatus &ddsstatus, const ::DDS::Rel
   ddsstatus.unacknowledged_sample_count_peak = status.unacknowledged_sample_count_peak;
 }
 
+#endif
+
 #endif /* DDS4CCM_RELIABLEWRITERCACHECHANGEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/RequestedDeadlineMissedStatus.h
index d07b1cf05f3..9d26f544d4b 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/RequestedDeadlineMissedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/RequestedDeadlineMissedStatus.h
@@ -12,6 +12,11 @@
 
 #include "InstanceHandle_t.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::RequestedDeadlineMissedStatus DDS_RequestedDeadlineMissedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::RequestedDeadlineMissedStatus &ddsstatus, const ::DDS_RequestedDeadlineMissedStatus & status)
 {
@@ -28,4 +33,6 @@ operator<<= (::DDS_RequestedDeadlineMissedStatus &ddsstatus, const ::DDS::Reques
   ddsstatus.last_instance_handle <<= status.last_instance_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_REQUESTEDDEADLINEMISSEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/RequestedIncompatibleQosStatus.h
index 81b5448266f..d36b9d7da1c 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/RequestedIncompatibleQosStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/RequestedIncompatibleQosStatus.h
@@ -13,6 +13,11 @@
 #include "QosPolicyCountSeq.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::RequestedIncompatibleQosStatus DDS_RequestedIncompatibleQosStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::RequestedIncompatibleQosStatus &ddsstatus, const ::DDS_RequestedIncompatibleQosStatus & status)
 {
@@ -31,4 +36,6 @@ operator<<= (::DDS_RequestedIncompatibleQosStatus &ddsstatus, const ::DDS::Reque
   ddsstatus.policies <<= status.policies;
 }
 
+#endif
+
 #endif /* DDS4CCM_REQUESTEDINCOMPATIBLEQOSSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ResourceLimitsQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/ResourceLimitsQosPolicy.h
index 52606fd7248..f7d2f2dd1f0 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/ResourceLimitsQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/ResourceLimitsQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::ResourceLimitsQosPolicy DDS_ResourceLimitsQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::ResourceLimitsQosPolicy &ddsqos, const ::DDS_ResourceLimitsQosPolicy & qos)
 {
@@ -27,4 +32,6 @@ operator<<= (::DDS_ResourceLimitsQosPolicy &ddsqos, const ::DDS::ResourceLimitsQ
   ddsqos.max_samples_per_instance = qos.max_samples_per_instance;
 }
 
+#endif
+
 #endif /* DDS4CCM_RESOURCELIMITSQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleInfo.h b/CIAO/connectors/dds4ccm/impl/ndds/SampleInfo.h
index 8a3be0255e1..53eb1d5bad6 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleInfo.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SampleInfo.h
@@ -15,6 +15,11 @@
 #include "Time_t.h"
 #include "InstanceHandle_t.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::SampleStateKind DDS_SampleStateKind;
+typedef ::DDS::SampleInfo DDS_SampleInfo;
+#endif
+
 inline void
 operator<<= (::CCM_DDS::AccessStatus & access_status, const ::DDS_SampleStateKind & sample_state)
 {
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleLostStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/SampleLostStatus.h
index 7aa6bdd6227..6191c745c17 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleLostStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SampleLostStatus.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::SampleLostStatus DDS_SampleLostStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::SampleLostStatus &ddsstatus, const ::DDS_SampleLostStatus & status)
 {
@@ -25,5 +30,7 @@ operator>>= (const ::DDS_SampleLostStatus &status, ::DDS::SampleLostStatus & dds
   ddsstatus.total_count = status.total_count;
   ddsstatus.total_count_change = status.total_count_change;
 }
+#endif
 
 #endif /* DDS4CCM_SAMPLELOSTSTATUS_H */
+
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/SampleRejectedStatus.h
index 18cd46949a7..2467b100e13 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SampleRejectedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SampleRejectedStatus.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::SampleRejectedStatus DDS_SampleRejectedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::SampleRejectedStatus &ddsstatus, const ::DDS_SampleRejectedStatus & status)
 {
@@ -31,4 +36,6 @@ operator<<= (::DDS_SampleRejectedStatus &ddsstatus, const ::DDS::SampleRejectedS
   ddsstatus.last_instance_handle <<= status.last_instance_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_SAMPLEREJECTEDSTATUS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/StringSeq.h b/CIAO/connectors/dds4ccm/impl/ndds/StringSeq.h
index c2db3f3c231..0f38b0cff92 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/StringSeq.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/StringSeq.h
@@ -11,6 +11,12 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::StringSeq DDS_StringSeq;
+typedef long DDS_Long;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::StringSeq & string_seq, const ::DDS_StringSeq & dds_string_seq)
 {
@@ -34,5 +40,6 @@ operator<<= (::DDS_StringSeq & dds_string_seq, const ::DDS::StringSeq & string_s
     dds_string_seq.from_array (parameterlist, string_seq.length ());
     delete [] parameterlist;
 }
+#endif
 
 #endif /* DDS4CCM_STRINGSEQ_T_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriberQos.h b/CIAO/connectors/dds4ccm/impl/ndds/SubscriberQos.h
index 15168ed07f3..9741f0b9682 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriberQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SubscriberQos.h
@@ -16,6 +16,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::SubscriberQos DDS_SubscriberQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::SubscriberQos &ddsqos, const ::DDS_SubscriberQos & qos)
 {
@@ -34,4 +39,6 @@ operator<<= (::DDS_SubscriberQos &ddsqos, const ::DDS::SubscriberQos & qos)
   ddsqos.entity_factory <<= qos.entity_factory;
 }
 
+#endif
+
 #endif /* DDS4CCM_SUBSCRIBERQOS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriptionBuiltinTopicData.h b/CIAO/connectors/dds4ccm/impl/ndds/SubscriptionBuiltinTopicData.h
index 792ef1c9f46..06f39b23e4b 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriptionBuiltinTopicData.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SubscriptionBuiltinTopicData.h
@@ -26,6 +26,7 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::SubscriptionBuiltinTopicData &ddstopicdata, const ::DDS_SubscriptionBuiltinTopicData & topicdata)
 {
@@ -74,4 +75,6 @@ operator<<= (::DDS_SubscriptionBuiltinTopicData & ddstopicdata, const ::DDS::Sub
   ddstopicdata.group_data <<= topicdata.group_data;
 }
 
+#endif
+
 #endif /* SUBSCRIPTIONBUILTINTOPICDATA_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h b/CIAO/connectors/dds4ccm/impl/ndds/SubscriptionMatchedStatus.h
index af54422bbd1..a8d02d7a24d 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/SubscriptionMatchedStatus.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/SubscriptionMatchedStatus.h
@@ -13,6 +13,11 @@
 #include "InstanceHandle_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::SubscriptionMatchedStatus DDS_SubscriptionMatchedStatus;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::SubscriptionMatchedStatus &ddsstatus, const ::DDS_SubscriptionMatchedStatus & status)
 {
@@ -33,5 +38,7 @@ operator<<= (::DDS_SubscriptionMatchedStatus &ddsstatus, const ::DDS::Subscripti
   ddsstatus.last_publication_handle <<= status.last_publication_handle;
 }
 
+#endif
+
 #endif /* DDS4CCM_SUBSCRIPTIONMATCHEDSTATUS_H */
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TimeBasedFilterQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/TimeBasedFilterQosPolicy.h
index efbe7f7292c..dfb3f711249 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TimeBasedFilterQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/TimeBasedFilterQosPolicy.h
@@ -12,6 +12,11 @@
 #include "Duration_t.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::TimeBasedFilterQosPolicy DDS_TimeBasedFilterQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::TimeBasedFilterQosPolicy &ddsqos, const ::DDS_TimeBasedFilterQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_TimeBasedFilterQosPolicy &ddsqos, const ::DDS::TimeBasedFilte
   ddsqos.minimum_separation <<= qos.minimum_separation;
 }
 
+#endif
+
 #endif /* DDS4CCM_TIMEBASEDFILTERQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/Time_t.h b/CIAO/connectors/dds4ccm/impl/ndds/Time_t.h
index ecaf3badf6b..e293fda3db1 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/Time_t.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/Time_t.h
@@ -12,6 +12,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::Time_t DDS_Time_t;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::Time_t &ddstime, const ::DDS_Time_t & time)
 {
@@ -26,5 +31,7 @@ operator<<= (::DDS_Time_t &ddstime, const ::DDS::Time_t & time)
   ddstime.nanosec = time.nanosec;
 }
 
+#endif
+
 #endif /* DDS4CCM_TIME_T_H_ */
 
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicBuiltinTopicData.h b/CIAO/connectors/dds4ccm/impl/ndds/TopicBuiltinTopicData.h
index eac901fd359..ca664800802 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicBuiltinTopicData.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/TopicBuiltinTopicData.h
@@ -24,6 +24,7 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::TopicBuiltinTopicData &ddstopicdata, const ::DDS_TopicBuiltinTopicData & topicdata)
 {
@@ -66,4 +67,6 @@ operator<<= (::DDS_TopicBuiltinTopicData & ddstopicdata, const ::DDS::TopicBuilt
   ddstopicdata.topic_data <<= topicdata.topic_data;
 }
 
+#endif
+
 #endif /* TOPICBUILTINTOPICDATA_H_ */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicDataQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/TopicDataQosPolicy.h
index fd55cba12d2..394b201ff77 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicDataQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/TopicDataQosPolicy.h
@@ -12,6 +12,11 @@
 #include "OctetSeq.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::TopicDataQosPolicy DDS_TopicDataQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::TopicDataQosPolicy &ddsqos, const ::DDS_TopicDataQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_TopicDataQosPolicy &ddsqos, const ::DDS::TopicDataQosPolicy &
   ddsqos.value <<= qos.value;
 }
 
+#endif
+
 #endif /* DDS4CCM_TOPICDATAQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/TopicDescription_T.cpp b/CIAO/connectors/dds4ccm/impl/ndds/TopicDescription_T.cpp
deleted file mode 100644
index 9e629ffc2b0..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/TopicDescription_T.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-// $Id$
-
-#include "TopicDescription_T.h"
-#include "DomainParticipant_T.h"
-
-#include "dds4ccm/idl/dds4ccm_BaseC.h"
-#include "dds4ccm/impl/Log_Macros.h"
-
-namespace CIAO
-{
-  namespace DDS4CCM
-  {
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::DDS_TopicDescription_T (
-      DDSTopicDescription * rc) : impl_ (rc)
-    {
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::~DDS_TopicDescription_T (void)
-    {
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    char *
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::get_type_name (void)
-    {
-      return CORBA::string_dup (this->impl ()->get_type_name ());
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    char *
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::get_name (void)
-    {
-      return CORBA::string_dup (this->impl ()->get_name ());
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    ::DDS::DomainParticipant_ptr
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::get_participant (void)
-    {
-      ::DDS::DomainParticipant_var retval;
-      DDSDomainParticipant* p = this->impl ()->get_participant ();
-      if (p)
-        {
-          ACE_NEW_THROW_EX (retval,
-                            DomainParticipant_type (p),
-                            ::CORBA::NO_MEMORY ());
-        }
-      return retval._retn ();
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDSTopicDescription *
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::get_impl (void)
-    {
-      return this->impl_;
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    void
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::set_impl (DDSTopicDescription * rc)
-    {
-      this->impl_ = rc;
-    }
-
-    template <typename DDS_TYPE, DDS4CCM_Vendor VENDOR_TYPE>
-    DDSTopicDescription *
-    DDS_TopicDescription_T<DDS_TYPE, VENDOR_TYPE>::impl (void)
-    {
-      if (!this->impl_)
-        {
-          throw ::CORBA::BAD_INV_ORDER ();
-        }
-      return this->impl_;
-    }
-  }
-}
-
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicQos.h b/CIAO/connectors/dds4ccm/impl/ndds/TopicQos.h
index 190c27d2d14..1cbc53d2b4b 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TopicQos.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/TopicQos.h
@@ -25,6 +25,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::TopicQos DDS_TopicQos;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::TopicQos &ddsqos, const ::DDS_TopicQos & qos)
 {
@@ -61,4 +66,6 @@ operator<<= (::DDS_TopicQos &ddsqos, const ::DDS::TopicQos & qos)
   ddsqos.ownership <<= qos.ownership;
 }
 
+#endif
+
 #endif /* DDS4CCM_TOPICQOS_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TransportPriorityQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/TransportPriorityQosPolicy.h
index 182ddbe9b25..3116b5f5bb5 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/TransportPriorityQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/TransportPriorityQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::TransportPriorityQosPolicy DDS_TransportPriorityQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::TransportPriorityQosPolicy &ddsqos, const ::DDS_TransportPriorityQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_TransportPriorityQosPolicy &ddsqos, const ::DDS::TransportPri
   ddsqos.value = qos.value;
 }
 
+#endif
+
 #endif /* DDS4CCM_TRANSPORTPRIOTITYQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/UserDataQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/UserDataQosPolicy.h
index db362576ec9..9e4dc792d5d 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/UserDataQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/UserDataQosPolicy.h
@@ -12,6 +12,11 @@
 #include "OctetSeq.h"
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::UserDataQosPolicy DDS_UserDataQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::UserDataQosPolicy &ddsqos, const ::DDS_UserDataQosPolicy & qos)
 {
@@ -24,4 +29,6 @@ operator<<= (::DDS_UserDataQosPolicy &ddsqos, const ::DDS::UserDataQosPolicy & q
   ddsqos.value <<= qos.value;
 }
 
+#endif
+
 #endif /* DDS4CCM_USERDATAQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/convertors/WriterDataLifecycleQosPolicy.h b/CIAO/connectors/dds4ccm/impl/ndds/WriterDataLifecycleQosPolicy.h
index 30e5e6a0add..6cecbb95c45 100644
--- a/CIAO/connectors/dds4ccm/impl/ndds/convertors/WriterDataLifecycleQosPolicy.h
+++ b/CIAO/connectors/dds4ccm/impl/ndds/WriterDataLifecycleQosPolicy.h
@@ -11,6 +11,11 @@
 
 #include "dds4ccm/impl/dds4ccm_conf.h"
 
+#if (CIAO_DDS4CCM_OPENDDS==1)
+typedef ::DDS::WriterDataLifecycleQosPolicy DDS_WriterDataLifecycleQosPolicy;
+#endif
+
+#if (CIAO_DDS4CCM_NDDS==1)
 inline void
 operator<<= (::DDS::WriterDataLifecycleQosPolicy &ddsqos, const ::DDS_WriterDataLifecycleQosPolicy & qos)
 {
@@ -23,4 +28,6 @@ operator<<= (::DDS_WriterDataLifecycleQosPolicy &ddsqos, const ::DDS::WriterData
   ddsqos.autodispose_unregistered_instances = qos.autodispose_unregistered_instances;
 }
 
+#endif
+
 #endif /* DDS4CCM_WRITERDATALIFECYCLEQOSPOLICY_H */
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h b/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h
deleted file mode 100644
index cce68d2f990..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_dds_ndds_export.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// -*- C++ -*-
-// $Id$
-// Definition for Win32 Export directives.
-// ------------------------------
-#ifndef DDS4CCM_DDS_NDDS_EXPORT_H
-#define DDS4CCM_DDS_NDDS_EXPORT_H
-
-#include "ace/config-all.h"
-
-#if defined (ACE_AS_STATIC_LIBS) && !defined (DDS4CCM_DDS_NDDS_HAS_DLL)
-#  define DDS4CCM_DDS_NDDS_HAS_DLL 0
-#endif /* ACE_AS_STATIC_LIBS && DDS4CCM_DDS_NDDS_HAS_DLL */
-
-#if !defined (DDS4CCM_DDS_NDDS_HAS_DLL)
-#  define DDS4CCM_DDS_NDDS_HAS_DLL 1
-#endif /* ! DDS4CCM_DDS_NDDS_HAS_DLL */
-
-#if defined (DDS4CCM_DDS_NDDS_HAS_DLL) && (DDS4CCM_DDS_NDDS_HAS_DLL == 1)
-#  if defined (DDS4CCM_DDS_NDDS_BUILD_DLL)
-#    define DDS4CCM_DDS_NDDS_Export ACE_Proper_Export_Flag
-#    define DDS4CCM_DDS_NDDS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
-#    define DDS4CCM_DDS_NDDS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#  else /* DDS4CCM_DDS_NDDS_BUILD_DLL */
-#    define DDS4CCM_DDS_NDDS_Export ACE_Proper_Import_Flag
-#    define DDS4CCM_DDS_NDDS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
-#    define DDS4CCM_DDS_NDDS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#  endif /* DDS4CCM_DDS_NDDS_BUILD_DLL */
-#else /* DDS4CCM_DDS_NDDS_HAS_DLL == 1 */
-#  define DDS4CCM_DDS_NDDS_Export
-#  define DDS4CCM_DDS_NDDS_SINGLETON_DECLARATION(T)
-#  define DDS4CCM_DDS_NDDS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
-#endif /* DDS4CCM_DDS_NDDS_HAS_DLL == 1 */
-
-#endif /* DDS4CCM_DDS_NDDS_EXPORT_H */
-
-// End of auto generated file.
diff --git a/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_ndds.mpc b/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_ndds.mpc
deleted file mode 100644
index a81356806e1..00000000000
--- a/CIAO/connectors/dds4ccm/impl/ndds/dds4ccm_ndds.mpc
+++ /dev/null
@@ -1,19 +0,0 @@
-project(CIAO_DDS4CCM_DDS_NDDS) : install, dds4ccm_skel, dds4ccm_lem_stub, taolib, ciao_output, ccm_stub, ciao_logger {
-
-  dynamicflags += DDS4CCM_DDS_NDDS_BUILD_DLL
-  macros += BUILDING_DDS_NDDS_LIB
-  Header_Files {
-    *.h
-    ndds/*.h
-  }
-
-  Template_Files {
-    *_T.cpp
-  }
-
-  Source_Files {
-    DataReader.cpp
-    DataWriter.cpp
-    StatusCondition.cpp
-  }
-}