// Previous API:
MyListener *my_listener = new MyListener();
reader.listener(my_listener, StatusMask::all());
// ...
reader.listener(NULL, StatusMask::none()); // user must reset the listener to destroy entity
delete my_listener;

// New API:
auto my_listener = std::make_shared<MyListener>();
reader.set_listener(my_listener);// No manual resource management required anymore

// Or simply:
reader.set_listener(std::make_shared<MyListener>());
 

dds::core::InstanceHandleSeq discovered_participants(
    DomainParticipant participant);

template <typename FwdIterator>
FwdIterator discovered_participants(
    DomainParticipant participant,
    FwdIterator begin,
    FwdIterator end);

dds::topic::ParticipantBuiltinTopicData discovered_participant_data(
    DomainParticipant participant,
    const dds::core::InstanceHandle& handle);

// Standard class (in dds namespace)
dds::domain::DomainParticipant participant(MY_DOMAIN_ID);
// Call a standard method
participant.assert_liveliness();
// Call an extension method:
participant->vendor_specific_method(...);

// Call an extension method:
participant.extensions().register_durable_subscription(...);

- const dds::sub::Subscriber&
- builtin_subscriber(const dds::domain::DomainParticipant& dp);
+ dds::sub::Subscriber 
+ builtin_subscriber(const dds::domain::DomainParticipant& dp);

diff --git a/src/hpp/dds/core/Exception.hpp b/src/hpp/dds/core/Exception.hpp
index 84c7c28..22b05ab 100644
--- a/src/hpp/dds/core/Exception.hpp
+++ b/src/hpp/dds/core/Exception.hpp
@@ -23,194 +23,261 @@
 #include <string>
 #include <dds/core/macros.hpp>

-namespace dds { namespace core {
+#if defined _MSC_VER
+#   pragma warning (push)
+#   pragma warning (disable:4275) // non dll-interface class 'std::foo_error' used as base for dll-interface class 'dds::core::BarError'
+#endif

-  /**
-   * This files contains the exceptions corresponding to DDS errors.
-   * In the DDS-PSM-Cxx in place of DDS errors the associated expcetion
-   * should be raised. Please section 7.5.5 of the DDS-PSM-C++ specification.
-   */
+namespace dds
+{
+namespace core
+{

-  class Exception
-  {
-  protected:
+/**
+ *
+ * DDS PIM Return Code            | DDS-PSM-CXX Exception Class   | std C++ Parent Exception
+ * -------------------            | ---------------------------   | ------------------------
+ * RETCODE_OK                     | Normal return; no exception   | N/A
+ * RETCODE_NO_DATA                | Normal return with informational state attached    | N/A
+ * RETCODE_ERROR                  | Error                         | std::logic_error
+ * RETCODE_BAD_PARAMETER          | InvalidArgumentError          | std::invalid_argument
+ * RETCODE_TIMEOUT                | TimeoutError                  | std::runtime_error
+ * RETCODE_UNSUPPORTED            | UnsupportedError              | std::logic_error
+ * RETCODE_ALREADY_DELETED        | AlreadyClosedError            | std::logic_error
+ * RETCODE_ILLEGAL_OPERATION      | IllegalOperationError         | std::logic_error
+ * RETCODE_NOT_ENABLED            | NotEnabledError               | std::logic_error
+ * RETCODE_PRECONDITION_NOT_MET   | PreconditionNotMetError       | std::logic_error
+ * RETCODE_IMMUTABLE_POLICY       | ImmutablePolicyError          | std::logic_error
+ * RETCODE_INCONSISTENT_POLICY    | InconsistentPolicyError       | std::logic_error
+ * RETCODE_OUT_OF_RESOURCES       | OutOfResourcesError           | std::runtime_error
+ *
+ * The DDS-PSM-Cxx maps error codes to C++ exceptions defined in the dds::core namespace and
+ * inheriting from a base Exception class and the appropriate standard C++ exception.
+ * Table 7.3 lists the mapping between error codes as defined in the DDS PIM and C++ exceptions
+ * as used in this specification. Exceptions have value semantics; this means that they must
+ * always have deep copy semantics.
+ * The full list of exceptions is included in the file dds/core/Exceptions.hpp.
+ *
+ */
+
+class OMG_DDS_API Exception
+{
+protected:
     Exception();
-  public:
-    virtual ~Exception() throw ();
+public:
+    virtual ~Exception() throw();

-  public:
-    virtual const char* what() const throw () = 0;
-  };
+public:
+    virtual const char* what() const throw() = 0;
+};

-  class Error : public Exception, public std::exception
-  {
-  public:
-    Error();
+/**
+ *  Generic, unspecified error.
+ */
+class OMG_DDS_API Error : public Exception, public std::logic_error
+{
+public:
+    explicit Error(const std::string& msg);
     Error(const Error& src);
-  public:
-    virtual ~Error() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~Error() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class AlreadyClosedError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * The object target of this operation has already been closed
+ */
+class OMG_DDS_API AlreadyClosedError : public Exception, public std::logic_error
+{
+public:
     explicit AlreadyClosedError(const std::string& msg);
     AlreadyClosedError(const AlreadyClosedError& src);
-    virtual ~AlreadyClosedError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~AlreadyClosedError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class IllegalOperationError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * An operation was invoked on an inappropriate object or at an inappropriate time
+ * (as determined by policies set by the specification or the Service implementation).
+ * There is no precondition that could be changed to make the operation succeed.
+ */
+class OMG_DDS_API IllegalOperationError : public Exception, public std::logic_error
+{
+public:
     explicit IllegalOperationError(const std::string& msg);
     IllegalOperationError(const IllegalOperationError& src);
-    virtual ~IllegalOperationError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~IllegalOperationError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class ImmutablePolicyError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * Application attempted to modify an immutable QosPolicy
+ */
+class OMG_DDS_API ImmutablePolicyError : public Exception, public std::logic_error
+{
+public:
     explicit ImmutablePolicyError(const std::string& msg);
     ImmutablePolicyError(const ImmutablePolicyError& src);
-    virtual ~ImmutablePolicyError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~ImmutablePolicyError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class InconsistentPolicyError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * Application specified a set of policies that are not
+ * consistent with each other
+ */
+class OMG_DDS_API InconsistentPolicyError : public Exception, public std::logic_error
+{
+public:
     explicit InconsistentPolicyError(const std::string& msg);
     InconsistentPolicyError(const InconsistentPolicyError& src);
-    virtual ~InconsistentPolicyError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~InconsistentPolicyError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class InvalidArgumentError : public Exception, public std::invalid_argument
-  {
-  public:
+/**
+ * Application is passing an invalid argument
+ */
+class OMG_DDS_API InvalidArgumentError : public Exception, public std::invalid_argument
+{
+public:
     explicit InvalidArgumentError(const std::string& msg);
     InvalidArgumentError(const InvalidArgumentError& src);
-    virtual ~InvalidArgumentError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~InvalidArgumentError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class NotEnabledError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * Operation invoked on an Entity that is not yet enabled
+ */
+class OMG_DDS_API NotEnabledError : public Exception, public std::logic_error
+{
+public:
     explicit NotEnabledError(const std::string& msg);
     NotEnabledError(const NotEnabledError& src);
-    virtual ~NotEnabledError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
+    virtual ~NotEnabledError() throw();

+public:
+    virtual const char* what() const throw();
+};

-  class OutOfResourcesError : public Exception, public std::runtime_error
-  {
-  public:
+/**
+ * Service ran out of the resources needed to complete the
+ * operation
+ */
+class OMG_DDS_API OutOfResourcesError : public Exception, public std::runtime_error
+{
+public:
     explicit OutOfResourcesError(const std::string& msg);
     OutOfResourcesError(const OutOfResourcesError& src);
-    virtual ~OutOfResourcesError() throw ();
-
-  public:
-    virtual const char* what() const throw ();
-  };
-
+    virtual ~OutOfResourcesError() throw();

-  class PreconditionNotMetError : public Exception, public std::logic_error
-  {
-  public:
-    explicit PreconditionNotMetError(const std::string& msg) : std::logic_error(msg) { }
-    PreconditionNotMetError(const PreconditionNotMetError& src) : std::logic_error(src.what()) {}
-    virtual ~PreconditionNotMetError() throw () { }
+public:
+    virtual const char* what() const throw();
+};

-  public:
-    virtual const char* what() const throw () {
-      return this->std::logic_error::what();
-    }

-  };
-
-
-  class TimeoutError : public Exception, public std::runtime_error
-  {
-  public:
+/**
+ * A pre-condition for the operation was not met
+ */
+class OMG_DDS_API PreconditionNotMetError : public Exception, public std::logic_error
+{
+public:
+    explicit PreconditionNotMetError(const std::string& msg);
+    PreconditionNotMetError(const PreconditionNotMetError& src);
+    virtual ~PreconditionNotMetError() throw();
+
+public:
+    virtual const char* what() const throw();
+};
+
+/**
+ * The operation timed out
+ */
+class OMG_DDS_API TimeoutError : public Exception, public std::runtime_error
+{
+public:
     explicit TimeoutError(const std::string& msg);
     TimeoutError(const TimeoutError& src);
-    virtual ~TimeoutError() throw ();
+    virtual ~TimeoutError() throw();

-  public:
-    virtual const char* what() const throw ();
-  };
+public:
+    virtual const char* what() const throw();
+};

-
-  class UnsupportedError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * Unsupported operation. Can only be returned by operations that are optional.
+ */
+class OMG_DDS_API UnsupportedError : public Exception, public std::logic_error
+{
+public:
     explicit UnsupportedError(const std::string& msg);
     UnsupportedError(const UnsupportedError& src);
-    virtual ~UnsupportedError() throw ();
+    virtual ~UnsupportedError() throw();

-  public:
-    virtual const char* what() const throw ();
-  };
+public:
+    virtual const char* what() const throw();
+};

-  class InvalidDowncastError : public Exception, public std::runtime_error
-  {
-  public:
+/**
+ * Application has attempted to cast incompatible types
+ */
+class OMG_DDS_API InvalidDowncastError : public Exception, public std::runtime_error
+{
+public:
     explicit InvalidDowncastError(const std::string& msg);
     InvalidDowncastError(const InvalidDowncastError& src);
     virtual ~InvalidDowncastError() throw();

-  public:
-    virtual const char* what() const throw ();
-  };
+public:
+    virtual const char* what() const throw();
+};

-  class NullReferenceError : public Exception, public std::runtime_error
-  {
-  public:
+/**
+ * Application returned a null reference
+ */
+class OMG_DDS_API NullReferenceError : public Exception, public std::runtime_error
+{
+public:
     explicit NullReferenceError(const std::string& msg);
     NullReferenceError(const NullReferenceError& src);
     virtual ~NullReferenceError() throw();

-  public:
-    virtual const char* what() const throw ();
-  };
+public:
+    virtual const char* what() const throw();
+};

-
-  class InvalidDataError : public Exception, public std::logic_error
-  {
-  public:
+/**
+ * Application returned invalid data
+ */
+class OMG_DDS_API InvalidDataError : public Exception, public std::logic_error
+{
+public:
     explicit InvalidDataError(const std::string& msg);
     InvalidDataError(const InvalidDataError& src);
-    virtual ~InvalidDataError() throw ();
+    virtual ~InvalidDataError() throw();
+
+public:
+    virtual const char* what() const throw();
+};
+
+}
+}

-  public:
-    virtual const char* what() const throw ();
-  };
+#if defined _MSC_VER
+#   pragma warning (pop)
+#endif

-}}

 #endif /* OMG_DDS_CORE_EXCEPTION_HPP_ */

diff --git a/src/hpp/dds/core/TQosProvider.hpp
b/src/hpp/dds/core/TQosProvider.hpp
index ef2a3e3..9cdda28 100644
--- a/src/hpp/dds/core/TQosProvider.hpp
+++ b/src/hpp/dds/core/TQosProvider.hpp
@@ -47,8 +47,8 @@ public:
    * For instance, the following code:
    * <pre><code>
          QosProvider xml_file_provider("file:///somewhere/on/disk/qos-config.xml");
-         QosProvider json_file_provider(""file:///somewhere/on/disk/json-config.json");
-         QosProvider json_http_provider(""http:///somewhere.org/here/json-config.json");
+         QosProvider json_file_provider("file:///somewhere/on/disk/json-config.json");
+         QosProvider json_http_provider("http:///somewhere.org/here/json-config.json");
       </code></pre>


    * The URI determines the how the Qos configuration is fetched and the

diff --git a/src/hpp/dds/core/TInstanceHandle.hpp
b/src/hpp/dds/core/TInstanceHandle.hpp
index c4c4014..b93975d 100644
--- a/src/hpp/dds/core/TInstanceHandle.hpp
+++ b/src/hpp/dds/core/TInstanceHandle.hpp
@@ -44,7 +44,7 @@ public:
   TInstanceHandle(const TInstanceHandle& other);


   /**
-   * Distructor
+   * Destructor
    */
   ~TInstanceHandle();

diff --git a/src/hpp/dds/domain/discovery.hpp b/src/hpp/dds/domain/discovery.hpp
index e43d28d..97943ec 100644
--- a/src/hpp/dds/domain/discovery.hpp
+++ b/src/hpp/dds/domain/discovery.hpp
@@ -26,7 +26,7 @@
 namespace dds { namespace domain {


   /**
-   * This function allows to express the will to ignore the entity
+   * This function allows one to express the will to ignore the entity
    * represented by the given <code>InstanceHandle</code> for the specific
    * <code>DomainParticipant</code>.
    *
@@ -40,7 +40,7 @@ namespace dds { namespace domain {
   void ignore(const dds::domain::DomainParticipant& dp, const dds::core::InstanceHandle& handle);


   /**
-   * This function allows to express the will to ignore a series of entities
+   * This function allows one to express the will to ignore a series of entities
    * whose instance handles are made available via the provided iterators.
    *
    * @param dp      the <code>DomainParticipant</code> for which the remote
diff --git a/src/hpp/dds/domain/find.hpp b/src/hpp/dds/domain/find.hpp
index 112d67c..2043f04 100644
--- a/src/hpp/dds/domain/find.hpp
+++ b/src/hpp/dds/domain/find.hpp
@@ -27,7 +27,7 @@ namespace dds { namespace domain {
   /**
    * This operation retrieves a previously created <code>DomainParticipant</code>
    * belonging to specified domain_id. If no such DomainParticipant
-   * exists, the operation will return a <it>nil</it> value.
+   * exists, the operation will return a @a nil value.
    *
    * @param id the domain id
    */

diff --git a/src/hpp/dds/dds.hpp b/src/hpp/dds/dds.hpp
index 9de7249..b6bf026 100644
--- a/src/hpp/dds/dds.hpp
+++ b/src/hpp/dds/dds.hpp
@@ -1,6 +1,28 @@
+/* Copyright 2010, Object Management Group, Inc.
+ * Copyright 2010, PrismTech, Corp.
+ * Copyright 2010, Real-Time Innovations, Inc.
+ * All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef __OMG_DDS_DDS_HPP__
 #define __OMG_DDS_DDS_HPP__


+/**
+ * @file
+ * This utility header includes the headers of all the DDS DCPS modules.
+ */
+
 #include <dds/core/ddscore.hpp>
 #include <dds/domain/ddsdomain.hpp>
 #include <dds/topic/ddstopic.hpp>
@@ -9,7 +14,5 @@
 #include <dds/pub/ddspub.hpp>


 #include <dds/core/QosProvider.hpp>
-#include <org/opensplice/topic/TopicTraits.hpp>
-


 #endif /* __OMG_DDS_DDS_HPP__ */

diff --git a/src/hpp/dds/core/status/TStatus.hpp b/src/hpp/dds/core/status/TStatus.hpp
index 638e188..6d6122f 100644
--- a/src/hpp/dds/core/status/TStatus.hpp
+++ b/src/hpp/dds/core/status/TStatus.hpp
@@ -138,7 +138,7 @@ namespace dds { namespace core { namespace status {
   template <typename D>
   class TPublicationMatchedStatus : public dds::core::Value<D> {
   public:
-    TPublicationMatchedStatus() : dds::core::Value<D>();
+    TPublicationMatchedStatus();


   public:
     int32_t total_count() const;

diff --git a/src/hpp/dds/core/status/State.hpp b/src/hpp/dds/core/status/State.hpp
index 8ac4475..ab8d1cf 100644
--- a/src/hpp/dds/core/status/State.hpp
+++ b/src/hpp/dds/core/status/State.hpp
@@ -21,19 +21,20 @@


 #include <bitset>
 #include <dds/core/macros.hpp>
+#include <dds/core/types.hpp>



 namespace dds { namespace core { namespace status {



-  class SampleRejectedState : public std::bitset<OMG_DDS_STATE_BIT_COUNT> {
+  class OMG_DDS_API SampleRejectedState : public std::bitset<OMG_DDS_STATE_BIT_COUNT> {
   public:
     typedef std::bitset<OMG_DDS_STATE_BIT_COUNT> MaskType;


   public:
-    SampleRejectedState() : MaskType() { }
-    SampleRejectedState(const SampleRejectedState& src) : MaskType(static_cast<int>(src.to_ulong())) { }
-    SampleRejectedState(const MaskType& src) : MaskType(static_cast<int>(src.to_ulong())) { }
+    SampleRejectedState();
+    SampleRejectedState(const SampleRejectedState& src);
+    SampleRejectedState(const MaskType& src);


   public:
     inline static const SampleRejectedState not_rejected() {
@@ -50,29 +51,29 @@ namespace dds { namespace core { namespace status {
     }


   private:
-    // @TODO
-    // -- This Ctor should be fixed as currently there is this
-    // -- cast only to avoid an error when compiling with the  MS vC++ compiler
-    SampleRejectedState(uint32_t s)
-    : MaskType((uint64_t)s)
-    { }
-
+    SampleRejectedState(uint32_t s);
   };



   // StatusMask create_status_mask(uint64_t);


-  class StatusMask : public std::bitset<OMG_DDS_STATUS_COUNT> {
+  class OMG_DDS_API StatusMask : public std::bitset<OMG_DDS_STATUS_COUNT> {
   public:
     typedef std::bitset<OMG_DDS_STATUS_COUNT> MaskType;


   public:
-    StatusMask() { }
-    explicit StatusMask(uint64_t mask) : std::bitset<OMG_DDS_STATUS_COUNT>(mask) { }
-    StatusMask(const StatusMask& other) : MaskType(static_cast<int>(other.to_ulong())) { }
-    ~StatusMask() { }
+    StatusMask();
+    explicit StatusMask(uint32_t mask);
+    StatusMask(const StatusMask& other);
+    ~StatusMask();


   public:
+    inline StatusMask& operator << (const dds::core::status::StatusMask& mask)
+    {
+        *this |= mask;
+        return *this;
+    }
+
     inline static const StatusMask all() {
       return StatusMask(0x7fe7u);
     }

diff --git a/src/hpp/dds/core/policy/TCorePolicy.hpp b/src/hpp/dds/core/policy/TCorePolicy.hpp
index 382e521..1313b32 100644
--- a/src/hpp/dds/core/policy/TCorePolicy.hpp
+++ b/src/hpp/dds/core/policy/TCorePolicy.hpp
@@ -47,7 +47,7 @@ namespace dds { namespace core { namespace policy {
     /**
      * Create a <code>UserData</code> instance with an empty user data.
      */
-    TUserData() : dds::core::Value<D>();
+    TUserData();


     /**
      * Create a <code>UserData</code> instance.
@@ -56,7 +56,7 @@ namespace dds { namespace core { namespace policy {
      */
     explicit TUserData(const dds::core::ByteSeq& seq);


-    //@TODO Implement
+    /** @todo Implement this */
     TUserData(const uint8_t* value_begin, const uint8_t* value_end);


     TUserData(const TUserData& other);
@@ -102,16 +102,16 @@ namespace dds { namespace core { namespace policy {
   class TGroupData : public dds::core::Value<D> {
   public:
     /**
-     * Create a <code>GroupData<code> instance.
+     * Create a <code>GroupData</code> instance.
      */
-    TGroupData() : dds::core::Value<D>();
+    TGroupData();


     /**
-     * Create a <code>GroupData<code> instance.
+     * Create a <code>GroupData</code> instance.
      *
      * @param seq the group data value
      */
-    explicit TGroupData(const dds::core::ByteSeq& seq) : dds::core::Value<D>(seq);
+    explicit TGroupData(const dds::core::ByteSeq& seq);


     TGroupData(const TGroupData& other);


@@ -160,7 +160,7 @@ namespace dds { namespace core { namespace policy {
   template <typename D>
   class TTopicData : public dds::core::Value<D> {
   public:
-    TTopicData() : dds::core::Value<D>();
+    TTopicData();


     explicit TTopicData(const dds::core::ByteSeq& seq);


@@ -219,7 +219,7 @@ namespace dds { namespace core { namespace policy {
   template <typename D>
   class TEntityFactory : public dds::core::Value<D> {
   public:
-    TEntityFactory() :dds::core::Value<D>(true);
+    TEntityFactory();
     explicit TEntityFactory(bool the_auto_enable);
     TEntityFactory(const TEntityFactory& other);


@@ -255,7 +255,7 @@ namespace dds { namespace core { namespace policy {
   public:
     explicit TTransportPriority(int32_t prio);


-    TTransportPriority() : dds::core::Value<D>(0);
+    TTransportPriority();


     TTransportPriority(const TTransportPriority& other);


@@ -554,7 +554,7 @@ namespace dds { namespace core { namespace policy {
     const dds::core::Duration max_blocking_time() const;


   public:
-    static TReliability Reliable(const dds::core::Duration& d = dds::core::Duration::infinite());
+    static TReliability Reliable(const dds::core::Duration& d = dds::core::Duration(0, 100000000));
     static TReliability BestEffort();
   };

diff --git a/src/hpp/dds/sub/AnyDataReaderListener.hpp b/src/hpp/dds/sub/AnyDataReaderListener.hpp
index 4646bfd..aabd71a 100644
--- a/src/hpp/dds/sub/AnyDataReaderListener.hpp
+++ b/src/hpp/dds/sub/AnyDataReaderListener.hpp
@@ -19,6 +19,8 @@
  * limitations under the License.
  */


+#include <dds/core/refmacros.hpp>
+#include <dds/core/status/Status.hpp>


 namespace dds { namespace sub {


@@ -59,37 +61,36 @@ namespace dds { namespace sub {
         const dds::core::status::SampleLostStatus& status) = 0;
   };


-
   class NoOpAnyDataReaderListener : public virtual AnyDataReaderListener {
   public:
-    virtual ~NoOpAnyDataReaderListener() { }
+    virtual ~NoOpAnyDataReaderListener();


   public:
     virtual void on_requested_deadline_missed(
         AnyDataReader& the_reader,
-        const dds::core::status::RequestedDeadlineMissedStatus& status) { }
+        const dds::core::status::RequestedDeadlineMissedStatus& status);


     virtual void on_requested_incompatible_qos(
         AnyDataReader& the_reader,
-        const dds::core::status::RequestedIncompatibleQosStatus& status) { }
+        const dds::core::status::RequestedIncompatibleQosStatus& status);


     virtual void on_sample_rejected(
         AnyDataReader& the_reader,
-        const dds::core::status::SampleRejectedStatus& status) { }
+        const dds::core::status::SampleRejectedStatus& status);


     virtual void on_liveliness_changed(
         AnyDataReader& the_reader,
-        const dds::core::status::LivelinessChangedStatus& status) { }
+        const dds::core::status::LivelinessChangedStatus& status);


-    virtual void on_data_available(AnyDataReader& the_reader) { }
+    virtual void on_data_available(AnyDataReader& the_reader);


     virtual void on_subscription_matched(
         AnyDataReader& the_reader,
-        const dds::core::status::SubscriptionMatchedStatus& status) { }
+        const dds::core::status::SubscriptionMatchedStatus& status);


     virtual void on_sample_lost(
         AnyDataReader& the_reader,
-        const dds::core::status::SampleLostStatus& status) { }
+        const dds::core::status::SampleLostStatus& status);
   };
 } }

diff --git a/src/hpp/dds/pub/find.hpp b/src/hpp/dds/pub/find.hpp
index 6c10f59..6a50fad 100644
--- a/src/hpp/dds/pub/find.hpp
+++ b/src/hpp/dds/pub/find.hpp
@@ -21,9 +21,9 @@


 #include <string>


+/** @todo This does not compile - no such example file (in spec). Need to add one */
 #include <dds/pub/detail/find.hpp>


-
 namespace dds { namespace pub {


   /**

diff --git a/src/hpp/dds/pub/TPublisher.hpp b/src/hpp/dds/pub/TPublisher.hpp
index 3534a29..d872370 100644
--- a/src/hpp/dds/pub/TPublisher.hpp
+++ b/src/hpp/dds/pub/TPublisher.hpp
@@ -97,16 +97,16 @@ public:
    *
    * @param pqos the new publisher QoS
    */
-  TPublisher& operator <<(const dds::pub::qos::PublisherQos& the_qos);
+  TPublisher& operator <<(const dds::pub::qos::PublisherQos& pqos);


   /**
    * Get the publisher qos policies.
    */
-  TPublisher& operator >> (dds::pub::qos::PublisherQos& the_qos);
+  TPublisher& operator >> (dds::pub::qos::PublisherQos& qos);


   /**
-   * This operation sets a default value of the <code>DataWriterQos<\code>
-   * which will be used for newly created <core>DataWriter<code>entities
+   * This operation sets a default value of the <code>DataWriterQos</code>
+   * which will be used for newly created <code>DataWriter</code>entities
    * for which no <code>DataWriterQos</code> is provided in the constructor.
    * This operation will check that the resulting policies are self consistent;
    * if they are not, the operation will have no effect and raise an
@@ -115,7 +115,7 @@ public:
   TPublisher& default_writer_qos(const dds::pub::qos::DataWriterQos& dwqos);


   /**
-   * This operation retrieves the default value of the <code>DataWriterQos<\code>,
+   * This operation retrieves the default value of the <code>DataWriterQos</code>,
    * that is, the QoS policies which will be used for newly created DataWriter
    * that don't provide a QoS parameter in the constructor.
    */
@@ -155,7 +155,7 @@ public:
   //==========================================================================


   /**
-   * Return the <code>DomainParticipant<code> that owns this Publisher.
+   * Return the <code>DomainParticipant</code> that owns this Publisher.
    */
   const dds::domain::DomainParticipant& participant() const;

@@ -143,19 +159,21 @@ public:
     * This operation blocks the calling thread until either all data written
     * by the reliable DataWriter entities is acknowledged by all matched
     * reliable DataReader entities, or else the duration specified by the
-     * max_wait parameter elapses, whichever happens first.
+     * timeout parameter elapses, whichever happens first.
     * A normal return indicates that all the samples written have been
-     * acknowledged by all reliable matched data readers; A TimeoutError
-     * indicates that max_wait elapsed before all the data was acknowledged.
+     * acknowledged by all reliable matched data readers. A TimeoutError
+     * indicates that timeout elapsed before all the data was acknowledged.
+     *
+     * @param timeout the time out duration
     */
    void wait_for_acknowledgments(const dds::core::Duration& timeout);

diff --git a/src/hpp/dds/sub/DataReader.hpp b/src/hpp/dds/sub/DataReader.hpp
index b38ddaa..b476779 100644
--- a/src/hpp/dds/sub/DataReader.hpp
+++ b/src/hpp/dds/sub/DataReader.hpp
@@ -1,10 +1,8 @@
 #ifndef OMG_DDS_SUB_DATA_READER_HPP_
 #define OMG_DDS_SUB_DATA_READER_HPP_


-#include <dds/sub/TDataReader.hpp>
 #include <dds/sub/detail/DataReader.hpp>


-
 namespace dds {
   namespace sub {
     template <typename T,
@@ -15,6 +13,7 @@ namespace dds {
   }
 }


+#include <dds/sub/TDataReader.hpp>


 // = Manipulators
 namespace dds {


diff --git a/src/hpp/dds/topic/ContentFilteredTopic.hpp b/src/hpp/dds/topic/ContentFilteredTopic.hpp
index 057a2f6..cbc5cfc 100644
--- a/src/hpp/dds/topic/ContentFilteredTopic.hpp
+++ b/src/hpp/dds/topic/ContentFilteredTopic.hpp
@@ -20,11 +20,12 @@
  */


 #include <dds/topic/detail/ContentFilteredTopic.hpp>
-#include <dds/topic/TContentFilteredTopic.hpp>


 namespace dds { namespace topic {
   template <typename T, template <typename Q> class DELEGATE = dds::topic::detail::ContentFilteredTopic>
   class ContentFilteredTopic;
 } }


+#include <dds/topic/TContentFilteredTopic.hpp>
+
 #endif /* OMG_DDS_TOPIC_CONTENT_FILTERED_TOPIC_HPP_ */


diff --git a/src/hpp/dds/topic/Topic.hpp b/src/hpp/dds/topic/Topic.hpp
index cd69316..5545f76 100644
--- a/src/hpp/dds/topic/Topic.hpp
+++ b/src/hpp/dds/topic/Topic.hpp
@@ -2,11 +2,12 @@
 #define OMG_DDS_TOPIC_TOPIC_HPP_


 #include <dds/topic/detail/Topic.hpp>
-#include <dds/topic/TTopic.hpp>


 namespace dds { namespace topic {
   template <typename T, template <typename Q> class DELEGATE = dds::topic::detail::Topic>
   class Topic;
 } }


+#include <dds/topic/TTopic.hpp>
+
 #endif /* OMG_DDS_TOPIC_TOPIC_HPP_ */


diff --git a/src/hpp/dds/topic/TopicDescription.hpp b/src/hpp/dds/topic/TopicDescription.hpp
index 47e2dd1..6e908b0 100644
--- a/src/hpp/dds/topic/TopicDescription.hpp
+++ b/src/hpp/dds/topic/TopicDescription.hpp
@@ -20,7 +20,6 @@
  */


 #include <dds/topic/detail/TopicDescription.hpp>
-#include <dds/topic/TTopicDescription.hpp>


 namespace dds { namespace topic {
   template <typename T,
@@ -28,5 +27,6 @@ namespace dds { namespace topic {
   class TopicDescription;
 } }


+#include <dds/topic/TTopicDescription.hpp>


 #endif /* OMG_DDS_TOPIC_TOPIC_DESCRIPTION_HPP_ */

diff --git a/src/hpp/dds/core/SafeEnumeration.hpp
b/src/hpp/dds/core/SafeEnumeration.hpp
index 3f7ca67..0d443c2 100644
--- a/src/hpp/dds/core/SafeEnumeration.hpp
+++ b/src/hpp/dds/core/SafeEnumeration.hpp
@@ -1,29 +1,76 @@
+/* Copyright 2010, Object Management Group, Inc.
+* Copyright 2010, PrismTech, Corp.
+* Copyright 2010, Real-Time Innovations, Inc.
+* All rights reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/

 #ifndef OMG_DDS_CORE_SAFEENUMERATION_HPP_
 #define OMG_DDS_CORE_SAFEENUMERATION_HPP_

namespace dds {
namespace core {
+/**
+ * safe_enum provides a wrapper for enumerated types in a typesafe
+ * manner.
+ * safe_enums allow specification of the underlying type,
+ * do not implictly convert to integers, and resolve scoping issues.
+ */
-    template<typename def, typename inner = typename def::type>
+    template<typename def, typename inner = typename def::Type>
     class safe_enum : public def
     {
-      typedef typename def::type type;
+      typedef typename def::Type type;
       inner val;

     public:
diff --git a/src/hpp/dds/core/policy/PolicyKind.hpp
b/src/hpp/dds/core/policy/PolicyKind.hpp
index 6928742..9537d78 100644
--- a/src/hpp/dds/core/policy/PolicyKind.hpp
+++ b/src/hpp/dds/core/policy/PolicyKind.hpp
@@ -25,7 +25,7 @@
 namespace dds { namespace core { namespace policy {


   struct OwnershipKind_def {
-    enum type {
+    enum Type {
       SHARED


 #ifdef  OMG_DDS_OWNERSHIP_SUPPORT
@@ -37,7 +37,7 @@ namespace dds { namespace core { namespace policy {
   typedef dds::core::safe_enum<OwnershipKind_def> OwnershipKind;


   struct DurabilityKind_def {
-    enum type {
+    enum Type {
       VOLATILE,
       TRANSIENT_LOCAL


@@ -46,8 +46,7 @@ namespace dds { namespace core { namespace policy {
       TRANSIENT,
       PERSISTENT
 #endif  // #ifdef  OMG_DDS_PERSISTENCE_SUPPORT
-    };
-  };
+    }; };
   typedef dds::core::safe_enum<DurabilityKind_def> DurabilityKind;


   struct PresentationAccessScopeKind_def  {
@@ -60,11 +59,11 @@ namespace dds { namespace core { namespace policy {
       GROUP
 #endif  // OMG_DDS_OBJECT_MODEL_SUPPORT
     }; };
-
+  typedef dds::core::safe_enum<PresentationAccessScopeKind_def>
PresentationAccessScopeKind;



   struct ReliabilityKind_def {
-    enum type {
+    enum Type {
       BEST_EFFORT,
       RELIABLE
     };
@@ -73,7 +72,7 @@ namespace dds { namespace core { namespace policy {



   struct DestinationOrderKind_def {
-    enum type {
+    enum Type {
       BY_RECEPTION_TIMESTAMP,
       BY_SOURCE_TIMESTAMP
     }; };
@@ -81,7 +80,7 @@ namespace dds { namespace core { namespace policy {
   typedef dds::core::safe_enum<DestinationOrderKind_def>
DestinationOrderKind;


   struct HistoryKind_def {
-    enum type {
+    enum Type {
       KEEP_LAST,
       KEEP_ALL
     };};
@@ -89,7 +88,7 @@ namespace dds { namespace core { namespace policy {
   typedef dds::core::safe_enum<HistoryKind_def> HistoryKind;


   struct LivelinessKind_def {
-    enum type {
+    enum Type {
       AUTOMATIC,
       MANUAL_BY_PARTICIPANT,
       MANUAL_BY_TOPIC
@@ -97,7 +96,7 @@ namespace dds { namespace core { namespace policy {
   typedef dds::core::safe_enum<LivelinessKind_def> LivelinessKind;


   struct TypeConsistencyEnforcementKind_def {
-    enum type {
+    enum Type {
       EXACT_TYPE_TYPE_CONSISTENCY,
       EXACT_NAME_TYPE_CONSISTENCY,
       DECLARED_TYPE_CONSISTENCY,

diff --git a/src/hpp/dds/core/Optional.hpp b/src/hpp/dds/core/Optional.hpp
index 5e563d0..7f1a1fc 100644
--- a/src/hpp/dds/core/Optional.hpp
+++ b/src/hpp/dds/core/Optional.hpp
@@ -24,7 +24,7 @@ namespace dds { namespace core {


   /**
    * The optional class is used to wrap attributes annotated with the
-   * @optional annotation. This class provides a simple and safe way of
+   * \@optional annotation. This class provides a simple and safe way of
    * accessing, setting and resetting the stored attribute.
    */
   template <typename T, template <typename Q> class DELEGATE>
   class optional : public dds::core::Value< DELEGATE<T> >
   {
   public:
     optional(const T& t);

   public:
     /**
      * Returns true only if the attribute is set.
      */
     bool is_set() const;

     /**
-     * Reset the attribute
+     * Reset the attribute.

diff --git a/src/hpp/dds/core/cond/detail/StatusCondition.hpp b/src/hpp/dds/core/cond/detail/StatusCondition.hpp
index 400c6c8..06f0198 100644
--- a/src/hpp/dds/core/cond/detail/StatusCondition.hpp
+++ b/src/hpp/dds/core/cond/detail/StatusCondition.hpp
@@ -27,7 +27,7 @@ namespace dds {
   namespace core {
     namespace cond {
       namespace detail {
-        typedef dds::core::cond::StatusCondition<foo::bar::core::cond::StatusCondition> StatusCondition;
+        typedef dds::core::cond::TStatusCondition<foo::bar::core::cond::StatusCondition> StatusCondition;
       }
     }
   }

diff --git a/src/hpp/dds/core/cond/TWaitSet.hpp b/src/hpp/dds/core/cond/TWaitSet.hpp
index dfb05a2..a7fa3ee 100644
--- a/src/hpp/dds/core/cond/TWaitSet.hpp
+++ b/src/hpp/dds/core/cond/TWaitSet.hpp
@@ -22,7 +22,9 @@
 #include <vector>


 #include <dds/core/types.hpp>
+#include <dds/core/Duration.hpp>
 #include <dds/core/cond/Condition.hpp>
+#include <dds/core/cond/WaitSet.hpp>


 namespace dds {
   namespace core {

@@ -39,209 +44,207 @@ namespace dds {
  * the attached Condition objects has a trigger_value of TRUE or else
  * until the timeout expires.
  * A WaitSet is not necessarily associated with a single DomainParticipant
- * and could be used to wait on Condition objects associated with different
+ * and could be used to wait for Condition objects associated with different
  * DomainParticipant objects.

 public:
-  OMG_DDS_REF_TYPE(TWaitSet, dds::core::Reference, DELEGATE)
+ OMG_DDS_REF_TYPE_PUBLIC(TWaitSet, dds::core::Reference, DELEGATE)

 public:
-  /**
-   * Creates a new waitset.
-   */
-  TWaitSet();
-
   ~TWaitSet();


 public:
 public:
  /**
   * This operation allows an application thread to wait for the occurrence
-   * of certain conditions. If none of the conditions attached to the
+  * of certain Conditions. If none of the Conditions attached to the
   * WaitSet have a trigger_value of TRUE, the wait operation will block
   * suspending the calling thread.
     *
     * The wait operation takes a timeout argument that specifies the maximum
-    * duration for the wait. It this duration is exceeded and none of
+    * duration for the wait. If this duration is exceeded and none of
     * the attached Condition objects is true, wait will continue and the
     * returned ConditionSeq will be empty.
     *
     * It is not allowed for more than one application thread to be waiting
     * on the same WaitSet. If the wait operation is invoked on a WaitSet that
-     * already has a thread blocking on it, the operation will raise
-     * immediately an exception PreconditionNotMet.
+     * already has a thread blocking on it, the operation will immediately 
+     * raise a PreconditionNotMet exception.
     *
     * The result of the wait operation is the list of all the attached
-     * conditions that have a trigger_value of TRUE (i.e., the conditions
+     * Conditions that have a trigger_value of TRUE (i.e., the Conditions
     * that unblocked the wait).
     *
     * @param timeout the maximum amount of time for which the wait
-     * should block while waiting for a condition to be triggered.
+     * should block while waiting for a Condition to be triggered.
     *
-     * @raise PreconditionNotMetException when multiple thread try to invoke
-     *        the method concurrently.
+     * @throws PreconditionNotMetException when multiple threads try to invoke
+     *        the function concurrently.
     *
-     * @return a vector containing the triggered conditions
+     * @return a vector containing the triggered Conditions
     */

@@ -95,11 +92,6 @@ public:
   /**
    * This operation allows an application thread to wait for the occurrence
-    * of certain conditions. If none of the conditions attached to the
+   * of certain Conditions. If none of the Conditions attached to the
    * WaitSet have a trigger_value of TRUE, the wait operation will block
    * suspending the calling thread.
    *
-   * The wait operation takes a timeout argument that specifies the maximum
-   * duration for the wait. It this duration is exceeded and none of
-   * the attached Condition objects is true, wait will continue and the
-   * returned ConditionSeq will be empty.
-   *
    * It is not allowed for more than one application thread to be waiting
    * on the same WaitSet. If the wait operation is invoked on a WaitSet that
-     * already has a thread blocking on it, the operation will raise
-     * immediately an exception PreconditionNotMet.
+     * already has a thread blocking on it, the operation will immediately 
+     * raise a PreconditionNotMet exception.
    *
    * The result of the wait operation is the list of all the attached
-    * conditions that have a trigger_value of TRUE (i.e., the conditions
+    * Conditions that have a trigger_value of TRUE (i.e., the Conditions
    * that unblocked the wait).
    *
-   * @param timeout the maximum amount of time for which the wait
-   * should block while waiting for a condition to be triggered.
-   *
-   * @raise PreconditionNotMetException when multiple thread try to invoke
+   * @throws PreconditionNotMetException when multiple threads try to invoke
    *        the method concurrently.
    *
-    * @return a vector containing the triggered conditions
+    * @return a vector containing the triggered Conditions
@@ -142,7 +131,7 @@ public:
   /**
    * This operation allows an application thread to wait for the occurrence
-    * of certain conditions. If none of the conditions attached to the
+    * of certain Conditions. If none of the Conditions attached to the
    * WaitSet have a trigger_value of TRUE, the wait operation will block
    * suspending the calling thread.
    *
    * The wait operation takes a timeout argument that specifies the maximum
-    * duration for the wait. It this duration is exceeded and none of
+    * duration for the wait. If this duration is exceeded and none of
    * the attached Condition objects is true, wait will continue and the
    * returned ConditionSeq will be empty.
    *
    * It is not allowed for more than one application thread to be waiting
    * on the same WaitSet. If the wait operation is invoked on a WaitSet that
-     * already has a thread blocking on it, the operation will raise
-     * immediately an exception PreconditionNotMet.
+     * already has a thread blocking on it, the operation will immediately 
+     * raise a PreconditionNotMet exception.
    *
    * The result of the wait operation is the list of all the attached
-    * conditions that have a trigger_value of TRUE (i.e., the conditions
+    * Conditions that have a trigger_value of TRUE (i.e., the Conditions
    * that unblocked the wait).
+    *
+    * @param triggered a ConditionSeq in which to put Conditions that were
+    * triggered during the wait.
    *
    * @param timeout the maximum amount of time for which the wait
-    * should block while waiting for a condition to be triggered.
+    * should block while waiting for a Condition to be triggered.
    *
-   * @raise PreconditionNotMetException when multiple thread try to invoke
+   * @throws PreconditionNotMetException when multiple threads try to invoke
    *        the method concurrently.
    *
-    * @return a vector containing the triggered conditions
+    * @return a vector containing the triggered Conditions
@@ -173,7 +162,7 @@ public:
    * This operation allows an application thread to wait for the occurrence
-    * of certain conditions. If none of the conditions attached to the
+    * of certain Conditions. If none of the Conditions attached to the
    * WaitSet have a trigger_value of TRUE, the wait operation will block
    * suspending the calling thread.
    *
    * The wait operation takes a timeout argument that specifies the maximum
-    * duration for the wait. It this duration is exceeded and none of
+    * duration for the wait. If this duration is exceeded and none of
    * the attached Condition objects is true, wait will continue and the
    * returned ConditionSeq will be empty.
    *
    * It is not allowed for more than one application thread to be waiting
    * on the same WaitSet. If the wait operation is invoked on a WaitSet that
-     * already has a thread blocking on it, the operation will raise
-     * immediately an exception PreconditionNotMet.
+     * already has a thread blocking on it, the operation will immediately 
+     * raise a PreconditionNotMet exception.
    *
    * The result of the wait operation is the list of all the attached
-    * conditions that have a trigger_value of TRUE (i.e., the conditions
+    * Conditions that have a trigger_value of TRUE (i.e., the Conditions
    * that unblocked the wait).
    *
+    * @param triggered a ConditionSeq in which to put Conditions that were
+    * triggered during the wait.
-    *
-    * @param timeout the maximum amount of time for which the wait
-    * should block while waiting for a condition to be triggered.
    *
-   * @raise PreconditionNotMetException when multiple thread try to invoke
+   * @throws PreconditionNotMetException when multiple threads try to invoke
    *        the method concurrently.
    *
-    * @return a vector containing the triggered conditions
+    * @return a vector containing the triggered Conditions
    ConditionSeq& wait(ConditionSeq& triggered);

public:
    /**
-     * Waits for at least one of the attached conditions to trigger and then
-     * dispatches the events.
+     * Waits for at least one of the attached Conditions to trigger and then
+     * dispatches the functor associated with the Condition.
     */
    void dispatch();

    /**
-     * Waits for at least one of the attached conditions to trigger and then
-     * dispatches the events, or, times out and unblocks.
+    * Waits for at least one of the attached Conditions to trigger and then
+     * dispatches the functor associated with the Condition, or, times
+     * out and unblocks.*
     */
    void dispatch(const dds::core::Duration& timeout);

@@ -199,12 +188,12 @@ public:
   /**
    * A synonym for attach_condition.
    */
-  WaitSet& operator +=(const dds::core::cond::Condition& cond);
+  TWaitSet& operator +=(const dds::core::cond::Condition& cond);


   /**
    * A synonym for detach_condition.
    */
-  WaitSet& operator -=(const dds::core::cond::Condition& cond);
+  TWaitSet& operator -=(const dds::core::cond::Condition& cond);


   /**
    * Attaches a Condition to the WaitSet. It is possible to attach a
@@ -216,7 +205,7 @@ public:
   /**
    * Attaches a Condition to the WaitSet. It is possible to attach a
    * Condition on a WaitSet that is currently being waited upon
    * (via the wait operation). In this case, if the Condition has a
-    * trigger_value of TRUE, then attaching the condition will unblock
+    * trigger_value of TRUE, then attaching the Condition will unblock
    * the WaitSet. Adding a Condition that is already attached to the WaitSet
    * has no effect.
    *
-    * @param cond the condition to be attached to this waitset.
+    * @param cond the Condition to be attached to this WaitSet.
+    *
+    * @return the WaitSet itself so that attaching Conditions
+    * can be chained.
    */
-  WaitSet& attach_condition(const dds::core::cond::Condition& cond);
+  TWaitSet& attach_condition(const dds::core::cond::Condition& cond);


   /**
    * Detaches a Condition from the WaitSet. If the Condition was not
    * attached to the WaitSet, the operation will return false.
    *
-    * @param cond the condition to detach from this WaitSet
+    * @param cond the Condition to detach from this WaitSet
    *
-    * @return true if the condition was found and detached, false if the
-    *         condition was not part of the WaitSet.
+    * @return true if the Condition was found and detached, false if the
+    *         Condition was not part of the WaitSet.
    */
   bool detach_condition(const dds::core::cond::Condition& cond);

   /**
-    * This operation retrieves the list of attached conditions.
+   * This operation retrieves the list of attached Conditions.
    *
-    * @return the list of attached conditions.
+    * @return the list of attached Conditions.
    */
-   const ConditionSeq conditions();
+   const ConditionSeq conditions() const;

   /**
-    * This operation retrieves the list of attached conditions.
+    * This operation retrieves the list of attached Conditions.
    *
+    * @param conds a ConditionSeq in which to put the attached
+    * Conditions.
+    *
-    * @return the list of attached conditions.
+    * @return the list of attached Conditions.
    */
   ConditionSeq& conditions(ConditionSeq& conds) const;
};

diff --git a/src/hpp/dds/core/cond/StatusCondition.hpp b/src/hpp/dds/core/cond/StatusCondition.hpp
index 4e33b3d..e500e39 100644
--- a/src/hpp/dds/core/cond/StatusCondition.hpp
+++ b/src/hpp/dds/core/cond/StatusCondition.hpp
@@ -22,7 +22,7 @@
 #include <dds/core/cond/TStatusCondition.hpp>


 namespace dds { namespace core { namespace cond {
-  typedef TStatusCondition<detail::StatusCondition> StatusCondition;
+  typedef detail::StatusCondition StatusCondition;
 } } }


 #endif /* OMG_DDS_CORE_STATUSCONDITION_HPP_ */

diff --git a/src/hpp/dds/core/array.hpp b/src/hpp/dds/core/array.hpp
index cd39d02..dfa910b 100644
--- a/src/hpp/dds/core/array.hpp
+++ b/src/hpp/dds/core/array.hpp
@@ -219,6 +219,8 @@ namespace dds {
     template<std::size_t _Int, typename _Tp>
        class tuple_element;


+    template <typename _Tp> class tuple_size;
+
     template<typename _Tp, std::size_t _Nm>
        struct tuple_size<array<_Tp, _Nm> >
        { static const std::size_t value = _Nm; };

diff --git a/src/hpp/dds/pub/AnyDataWriter.hpp b/src/hpp/dds/pub/AnyDataWriter.hpp
index b6bbde2..6d0bad5 100644
--- a/src/hpp/dds/pub/AnyDataWriter.hpp
+++ b/src/hpp/dds/pub/AnyDataWriter.hpp
@@ -72,9 +72,6 @@ public:
   template <typename T> AnyDataWriter&
   operator =(const dds::pub::DataWriter<T>& rhs);


-  template <typename T>
-  AnyDataWriter& operator =(const AnyDataWriter& rhs);
-
   inline AnyDataWriter& operator =(AnyDataWriter rhs);


 public:

diff --git a/src/hpp/dds/domain/qos/detail/DomainParticipantQos.hpp b/src/hpp/dds/domain/qos/detail/DomainParticipantQos.hpp
index 9007702..c57454d 100644
--- a/src/hpp/dds/domain/qos/detail/DomainParticipantQos.hpp
+++ b/src/hpp/dds/domain/qos/detail/DomainParticipantQos.hpp
@@ -28,7 +28,7 @@ namespace dds {
   namespace domain {
     namespace qos {
       namespace detail {
-      typedef ::dds::core::qos::TEntityQos< foo::bar::domain::qos::DomainParticipantQos >
+      typedef ::dds::core::TEntityQos< foo::bar::domain::qos::DomainParticipantQos >
       DomainParticipantQos;
       }
     }

diff --git a/src/hpp/dds/domain/TDomainParticipant.hpp
b/src/hpp/dds/domain/TDomainParticipant.hpp
index ce51ea9..3bf7bb0 100644
--- a/src/hpp/dds/domain/TDomainParticipant.hpp
+++ b/src/hpp/dds/domain/TDomainParticipant.hpp
@@ -75,8 +75,7 @@ public:
    *           <code>DomainParticipant</code>.
    *
    */
-  TDomainParticipant(uint32_t did)
-  : ::dds::core::TEntity<DELEGATE>(new DELEGATE(did));
+  TDomainParticipant(uint32_t id);


   /**
    * Create a new <code>DomainParticipant</code> object.
@@ -103,11 +102,11 @@ public:
 public:


   /**
-   * Register a listener with the <core>DomainParticipant</code>.
+   * Register a listener with the <code>DomainParticipant</code>.
    * The notifications received by the listener depend on the
    * status mask with which it was registered.
    *
    * @param listener the listener
    * @param event_mask the mask defining the events for which the listener
    *  will be notified.
    */
-    void listener(Listener* the_listener,listener,
+    void listener(Listener* listener,listener,
                  const ::dds::core::status::StatusMask& event_mask);

@@ -144,19 +151,18 @@ public:

    /**
     * This operation manually asserts the liveliness of the DataWriter.
-     * This is used in combination with the LIVELINESS QoS policy
+     * This is used in combination with the Liveliness QoS policy
     * (see Section 7.1.3, Supported QoS, on page 96) to indicate to the
     * Service that the entity remains active.
     * This operation need only be used if the LIVELINESS setting is either
     * MANUAL_BY_PARTICIPANT or MANUAL_BY_TOPIC. Otherwise, it has no effect.
     *
-     * <b>Note</b> Writing data via the write operation on a DataWriter
+     * Note: Writing data via the write operation on a DataWriter
     * asserts liveliness on the DataWriter itself and its DomainParticipant.
     * Consequently the use of assert_liveliness is only needed if the
     * application is not writing data regularly.
     */
    void assert_liveliness();


    /**

@@ -187,17 +193,70 @@ public:
+    /**
+     * Set the QoS associated with this DomainParticipant.
+     * @param qos the new DomainParticipant QoS
+     */
+    dds::domain::qos::DomainParticipantQos& operator << (const dds::domain::qos::DomainParticipantQos& qos);
+
+    /**
+     * Get the QoS associated with this DomainParticipant.
+     *
+     * @param qos the current DomainParticipant QoS
+     */
+    const TDomainParticipant& operator >> (dds::domain::qos::DomainParticipantQos& qos) const;

diff --git a/src/hpp/dds/domain/TDomainId.hpp b/src/hpp/dds/domain/TDomainId.hpp
deleted file mode 100644
index dc6d9af..0000000
--- a/src/hpp/dds/domain/TDomainId.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef OMG_DDS_DOMAIN_T_DOMAIN_ID_HPP_
-#define OMG_DDS_DOMAIN_T_DOMAIN_ID_HPP_
-
-#include <dds/core/Value.hpp>
-
-namespace dds { namespace domain {
-  template <typename DELEGATE>
-  class TDomainId;
-} }
-
-
-template <typename DELEGATE>
-class dds::domain::TDomainId : public dds::core::Value<DELEGATE> {
-public:
-
-  template <typename ARG0>
-  TDomainId(ARG0 id) : dds::core::Value<DELEGATE>(id);
-
-  template <typename ARG0, typename ARG1>
-  TDomainId(ARG0 arg0, ARG1 arg1);
-
-  operator uint32_t () const;
-
-  uint32_t value() const;
-
-  static const TDomainId default_domain();
-};
-
-#endif /* OMG_DDS_DOMAIN_T_DOMAIN_ID_HPP_ */

diff --git a/src/hpp/dds/core/types.hpp b/src/hpp/dds/core/types.hpp
index c58e002..90c56f4 100644
--- a/src/hpp/dds/core/types.hpp
+++ b/src/hpp/dds/core/types.hpp
@@ -33,8 +33,8 @@ namespace dds { namespace core {
   typedef std::vector<std::string> StringSeq;


   // DDS Null-Reference
-  class null_type { };
-  extern const null_type null;
+  class OMG_DDS_API null_type { };
+  extern const null_type OMG_DDS_API null;



 #ifdef OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT

diff --git a/src/hpp/dds/core/ref_traits.hpp b/src/hpp/dds/core/ref_traits.hpp
index 5a34f6f..ff469d1 100644
--- a/src/hpp/dds/core/ref_traits.hpp
+++ b/src/hpp/dds/core/ref_traits.hpp
@@ -19,11 +19,13 @@
  * limitations under the License.
  */


-/**
+
+namespace  dds { namespace core {
+
+/*
  * These traits have to be provided by compliant implementations
  * to enable safe polymorphic casts.
  */
-namespace  dds { namespace core {


   template <typename T1, typename T2>
   struct is_base_of;

@@ -38,12 +43,12 @@ namespace  dds { namespace core {
TO  polymorphic_cast(FROM& from);


}
} /* namespace dds / namespace core */


// This include should stay here as it provides implementations
-// for the declaration just above.
+// for the declaration immediately above.
#include <dds/core/detail/ref_traits.hpp>

#endif /* OMG_DDS_CORE_REF_TRAITS_H_ */

diff --git a/src/hpp/dds/core/detail/conformance.hpp b/src/hpp/dds/core/detail/conformance.hpp
index f8b5f9b..bb8e974 100644
--- a/src/hpp/dds/core/detail/conformance.hpp
+++ b/src/hpp/dds/core/detail/conformance.hpp
@@ -22,6 +22,7 @@
 #define OMG_DDS_OBJECT_MODEL_SUPPORT                        FULL
 #define OMG_DDS_EXTENSIBLE_AND_DYNAMIC_TOPIC_TYPE_SUPPORT   FULL
 #define OMG_DDS_X_TYPES_DYNANIC_TYPE_SUPPORT                FULL
+#define OMG_DDS_X_TYPES_BUILTIN_TOPIC_TYPES_SUPPORT         FULL
 #define OMG_DDS_HAS_PRETTY_PRINT_COUT 1


 #endif /* OMG_DDS_CORE_DETAIL_CONFORMANCE_HPP_ */

diff --git a/src/hpp/dds/pub/qos/detail/DataWriterQos.hpp b/src/hpp/dds/pub/qos/detail/DataWriterQos.hpp
index 67483ec..2f7a23e 100644
--- a/src/hpp/dds/pub/qos/detail/DataWriterQos.hpp
+++ b/src/hpp/dds/pub/qos/detail/DataWriterQos.hpp
@@ -23,7 +23,7 @@
 #include <foo/bar/pub/qos/DataWriterQos.hpp>


 namespace dds { namespace pub { namespace qos { namespace detail {
-  typedef dds::core::qos::TEntityQos<foo::bar::pub::qos::DataWriterQos> DataWriterQos;
+  typedef dds::core::TEntityQos<foo::bar::pub::qos::DataWriterQos> DataWriterQos;
 } } } }


 #endif /* OMG_DDS_QOS_DETAIL_DATA_WRITER_QOS_HPP_ */
diff --git a/src/hpp/dds/pub/qos/detail/PublisherQos.hpp b/src/hpp/dds/pub/qos/detail/PublisherQos.hpp
index 1abff41..a60635b 100644
--- a/src/hpp/dds/pub/qos/detail/PublisherQos.hpp
+++ b/src/hpp/dds/pub/qos/detail/PublisherQos.hpp
@@ -23,7 +23,7 @@
 #include <foo/bar/pub/qos/PublisherQos.hpp>


 namespace dds { namespace pub { namespace qos { namespace detail {
-  typedef dds::core::qos::TEntityQos<foo::bar::pub::qos::PublisherQos> PublisherQos;
+  typedef dds::core::TEntityQos<foo::bar::pub::qos::PublisherQos> PublisherQos;
 } } } }


 #endif /* OMG_DDS_PUB_QOS_DETAIL_PUBLISER_QOS_HPP_ */

diff --git a/src/hpp/dds/pub/discovery.hpp b/src/hpp/dds/pub/discovery.hpp
index f50e179..5a8eb28 100644
--- a/src/hpp/dds/pub/discovery.hpp
+++ b/src/hpp/dds/pub/discovery.hpp
@@ -40,8 +40,6 @@ namespace dds { namespace pub {
    * @param dp      the <code>DomainParticipant</code> for which the remote
    *                entity will be ignored
    *
-   * @param handle  the <code>InstanceHandle</code> of the remote entity that
-   *                has to be ignored
    */
   template <typename FwdIterator>
   void ignore(const dds::domain::DomainParticipant& dp, FwdIterator begin, FwdIterator end);

diff --git a/src/hpp/dds/pub/TSuspendedPublication.hpp b/src/hpp/dds/pub/TSuspendedPublication.hpp
index fcd096b..ac4ea26 100644
--- a/src/hpp/dds/pub/TSuspendedPublication.hpp
+++ b/src/hpp/dds/pub/TSuspendedPublication.hpp
@@ -72,7 +72,7 @@ public:
    * suspend_publications. Otherwise the operation will return the
    * error PRECONDITION_NOT_MET.
    */
-  ~SuspendedPublication();    // resumes publications implicitly
+  ~TSuspendedPublication();    // resumes publications implicitly
 };

diff --git a/src/hpp/dds/sub/DataReaderListener.hpp b/src/hpp/dds/sub/DataReaderListener.hpp
index 17c620e..70b2777 100644
--- a/src/hpp/dds/sub/DataReaderListener.hpp
+++ b/src/hpp/dds/sub/DataReaderListener.hpp
@@ -32,10 +32,10 @@ namespace dds { namespace sub {
 template <typename T>
 class dds::sub::DataReaderListener {
 public:
-  typedef ::dds::core::smart_ptr_traits<DataReaderListener>::ref_type ref_type;
+  typedef typename ::dds::core::smart_ptr_traits<DataReaderListener>::ref_type ref_type;


 public:
-  virtual ~DataReaderListener();
+  virtual ~DataReaderListener() = 0;


 public:
   virtual void on_requested_deadline_missed(
@@ -69,7 +69,7 @@ public:
 template <typename T>
 class dds::sub::NoOpDataReaderListener : public virtual DataReaderListener<T> {
 public:
-  typedef ::dds::core::smart_ptr_traits<NoOpDataReaderListener>::ref_type ref_type;
+  typedef typename ::dds::core::smart_ptr_traits<NoOpDataReaderListener>::ref_type ref_type;


 public:
   virtual ~NoOpDataReaderListener();

template <typename TOPIC>
TOPIC discover(const dds::domain::DomainParticipant& dp,
               const std::string& name,
               const dds::core::Duration& timeout = dds::core::Duration::infinite());

template <typename ANYTOPIC, typename BinIterator>
uint32_t discover(const dds::domain::DomainParticipant& dp, BinIterator begin);

#define BUILTIN_TOPIC_KEY_TYPE_NATIVE long

module DDS {
    struct BuiltinTopicKey_t {
        BUILTIN_TOPIC_KEY_TYPE_NATIVE value[3];
    };
};

template <typename D>
class dds::topic::TBuiltinTopicKey : public ::dds::core::Value<D>
{
public:
    /**
     * Gets the BuiltinTopicKey.
     *
     * @return the BuiltinTopicKey
     */
    const int32_t* value() const;

    /**
     * Sets the BuiltinTopicKey.
     *
     * @param v the value to set
     */
    void value(const int32_t v[]);
};

template <class T, class U>
bool operator <(
        const dds::core::Reference<T>& a,
        const dds::core::Reference<U>& b) OMG_NOEXCEPT
{
    return a.delegate().get() < b.delegate().get();
}

template <class T, class U>
bool operator <=(
        const dds::core::Reference<T>& a,
        const dds::core::Reference<U>& b) OMG_NOEXCEPT
{
    return a.delegate().get() <= b.delegate().get();
}

template <class T, class U>
bool operator >(
        const dds::core::Reference<T>& a,
        const dds::core::Reference<U>& b) OMG_NOEXCEPT
{
    return a.delegate().get() > b.delegate().get();
}

template <class T, class U>
bool operator >=(
        const dds::core::Reference<T>& a,
        const dds::core::Reference<U>& b) OMG_NOEXCEPT
{
    return a.delegate().get() >= b.delegate().get();
}

namespace dds { namespace topic {

/** 
 * @brief Participant builtin topic name 
 *  
 * Topic name of the builtin dds::sub::DataReader for the 
 * dds::topic::ParticipantBuiltinTopicData type 
 */
OMG_DDS_API std::string participant_topic_name();

/** 
 * @brief Topic topic name 
 *  
 * Topic name of the builtin dds::sub::DataReader for the 
 * dds::topic::TopicBuiltinTopicData type 
 */
OMG_DDS_API std::string topic_topic_name();

/** 
 * @brief  Publication topic name 
 *  
 * Topic name of the builtin dds::sub::DataReader for the 
 * dds::topic::PublicationBuiltinTopicData type 
 */
OMG_DDS_API std::string publication_topic_name();

/** 
 * @brief Subscription topic name 
 *  
 * Topic name of the builtin dds::sub::DataReader for the 
 * dds::topic::SubscriptionBuiltinTopicData type 
 */
OMG_DDS_API std::string subscription_topic_name();

} }  // namespace dds::topic

    /**
     * @brief Allow implicit creation from std::chrono::duration
     *
     * For example:
     * \code
     * dds::core::cond::WaitSet waitset;
     * // ...
     * waitset.wait(std::chrono::seconds(1) + std::chrono::milliseconds(250));
     * \endcode
     *
     */
    template <typename Rep, typename Period>
    /* implicit */ Duration(const std::chrono::duration<Rep, Period>& duration)
        : sec_(static_cast<int32_t>(
              std::chrono::duration_cast<std::chrono::seconds, Rep, Period>(duration).count())),
          nsec_(static_cast<uint32_t>(
              (std::chrono::nanoseconds(duration) % 1000000000).count()))
    {
    }

struct Time_t {
long sec;
unsigned long nanosec;
};

+ #include <dds/sub/discovery.hpp>

- const dds::topic::BuiltinTopicKey& key();
+ const dds::topic::BuiltinTopicKey& key() const;

Selector& next_instance(const dds::core::InstanceHandle& h)

/local/VxWorks/GPP-3.6/gnu/4.1.2-vxworks-6.6/sun4-solaris2/bin/../../lib/gcc/../../include/c++/4.1/xmemory:37: error: no matching function for call to 'dds::core::TEntity<rti::core::Entity>::operator new(unsigned int, void*&)'
../../../hpp/dds/core/Reference.hpp:184: note: candidates are: static void* dds::core::Reference<DELEGATE>::operator new(size_t) [with DELEGATE = rti::core::Entity]

  template <typename ARG0>
  TInstanceHandle(const ARG0& arg0);

  template <typename ARG0>
  explicit TInstanceHandle(const ARG0& arg0);

dr >> read >> ... >> loaned_samples;

-  template <typename SELECTOR>
-  SELECTOR& read(SELECTOR& selector);
+  OMG_DDS_API
+  bool read(dds::sub::ReadModeDummyType);

-  template <typename SELECTOR>
-  SELECTOR& take(SELECTOR& selector);
+  OMG_DDS_API
+  bool take(dds::sub::ReadModeDummyType);

+class ReadModeDummyType {};

…

-  ManipulatorSelector
-  operator >> (ManipulatorSelector& (manipulator)(ManipulatorSelector&));
+        ManipulatorSelector&
+        operator >>(bool(*manipulator)(ReadModeDummyType))