DDSPSMC11_ — API correction required to src/hpp/dds/core/cond/TWaitSet.hpp

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;
};