Rename get and set of enabled status to mask

Signed-off-by: Firas Sahli <firas.sahli@adlinktech.com>

src/core/ddsc/include/ddsc/dds.h

@@ -516,9 +516,15 @@ dds_get_status_changes(
  */
 _Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
 DDS_EXPORT _Check_return_ dds_return_t
-dds_get_enabled_status(
+dds_get_status_mask(
         _In_  dds_entity_t entity,
-        _Out_ uint32_t *status);
+        _Out_ uint32_t *mask);
+
+_Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
+DDS_EXPORT _Check_return_ dds_return_t
+DDS_DEPRECATED_EXPORT dds_get_enabled_status(
+        _In_  dds_entity_t entity,
+        _Out_ uint32_t *mask);
 
 /**
  * @brief Set status enabled on entity
@@ -541,6 +547,13 @@ dds_get_enabled_status(
  */
 _Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
 DDS_EXPORT dds_return_t
+dds_set_status_mask(
+        _In_ dds_entity_t entity,
+        _In_ uint32_t mask);
+
+_Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
+DDS_EXPORT dds_return_t
+DDS_DEPRECATED_EXPORT
 dds_set_enabled_status(
         _In_ dds_entity_t entity,
         _In_ uint32_t mask);

src/core/ddsc/src/dds_entity.c

@@ -753,22 +753,22 @@ dds_get_status_changes(
 
 _Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
 _Check_return_ dds_return_t
-dds_get_enabled_status(
+dds_get_status_mask(
         _In_    dds_entity_t entity,
-        _Out_   uint32_t *status)
+        _Out_   uint32_t *mask)
 {
     dds_entity *e;
     dds__retcode_t rc;
     dds_return_t ret;
 
-    if (status != NULL) {
+    if (mask != NULL) {
         rc = dds_entity_lock(entity, DDS_KIND_DONTCARE, &e);
         if (rc == DDS_RETCODE_OK) {
             if (e->m_deriver.validate_status) {
-                *status = (e->m_status_enable & ~DDS_INTERNAL_STATUS_MASK);
+                *mask = (e->m_status_enable & ~DDS_INTERNAL_STATUS_MASK);
                 ret = DDS_RETCODE_OK;
             } else {
-                DDS_ERROR("This entity does not maintain a status\n");
+                DDS_ERROR("This entity does not maintain a status mask\n");
                 ret = DDS_ERRNO(DDS_RETCODE_ILLEGAL_OPERATION);
             }
             dds_entity_unlock(e);
@@ -777,18 +777,27 @@ dds_get_enabled_status(
             ret = DDS_ERRNO(rc);
         }
     } else{
-        DDS_ERROR("Argument status is NULL\n");
+        DDS_ERROR("Argument mask is NULL\n");
         ret = DDS_ERRNO(DDS_RETCODE_BAD_PARAMETER);
     }
 
     return ret;
 }
 
+_Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
+_Check_return_ dds_return_t
+dds_get_enabled_status(
+        _In_    dds_entity_t entity,
+        _Out_   uint32_t *status)
+{
+    return dds_get_status_mask(entity, status);
+}
+
 
 
 _Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
 DDS_EXPORT dds_return_t
-dds_set_enabled_status(
+dds_set_status_mask(
         _In_ dds_entity_t entity,
         _In_ uint32_t mask)
 {
@@ -822,6 +831,15 @@ dds_set_enabled_status(
     return ret;
 }
 
+_Pre_satisfies_(entity & DDS_ENTITY_KIND_MASK)
+DDS_EXPORT dds_return_t
+dds_set_enabled_status(
+        _In_ dds_entity_t entity,
+        _In_ uint32_t mask)
+{
+    return dds_set_status_mask(entity, mask);
+}
+
 
 
 

src/core/ddsc/tests/dispose.c

@@ -80,7 +80,7 @@ disposing_init(void)
     CU_ASSERT_FATAL(g_writer > 0 );
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -91,7 +91,7 @@ disposing_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -454,7 +454,7 @@ CU_Test(ddsc_writedispose_ts, disposing_past_sample, .init=disposing_init, .fini
     dds_return_t ret;
 
     /* Disposing a sample in the past should trigger a lost sample. */
-    ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -807,7 +807,7 @@ CU_Test(ddsc_dispose_ts, disposing_past_sample, .init=disposing_init, .fini=disp
     dds_return_t ret;
 
     /* Disposing a sample in the past should trigger a lost sample. */
-    ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -1047,7 +1047,7 @@ CU_Test(ddsc_dispose_ih_ts, disposing_past_sample, .init=disposing_init, .fini=d
     dds_return_t ret;
 
     /* Disposing a sample in the past should trigger a lost sample. */
-    ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/entity_api.c

@@ -214,26 +214,26 @@ CU_Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity)
      * for the specific entity children, not for the generic part. */
 
     /* Check getting Status with bad parameters. */
-    status1 = dds_get_enabled_status (0, NULL);
+    status1 = dds_get_status_mask (0, NULL);
     cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
-    status1 = dds_get_enabled_status (entity, NULL);
+    status1 = dds_get_status_mask (entity, NULL);
     cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
-    status1 = dds_get_enabled_status (0, &s1);
+    status1 = dds_get_status_mask (0, &s1);
     cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
 
     /* Get Status, which should be 0 for a participant. */
-    status1 = dds_get_enabled_status (entity, &s1);
+    status1 = dds_get_status_mask (entity, &s1);
     cu_assert_status_eq(status1, DDS_RETCODE_OK);
     CU_ASSERT_EQUAL_FATAL(s1, 0);
 
     /* Check setting Status with bad parameters. */
-    status1 = dds_set_enabled_status (0, 0);
+    status1 = dds_set_status_mask (0, 0);
     cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
 
     /* I shouldn't be able to set statuses on a participant. */
-    status1 = dds_set_enabled_status (entity, 0);
+    status1 = dds_set_status_mask (entity, 0);
     cu_assert_status_eq(status1, DDS_RETCODE_OK);
-    status1 = dds_set_enabled_status (entity, DDS_DATA_AVAILABLE_STATUS);
+    status1 = dds_set_status_mask (entity, DDS_DATA_AVAILABLE_STATUS);
     cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER);
 
     /* Check getting Status changes with bad parameters. */

src/core/ddsc/tests/entity_status.c

@@ -122,7 +122,7 @@ fini_entity_status(void)
 CU_Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini=fini_entity_status)
 {
     /* We're interested in publication matched status. */
-    ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(wri, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for publication matched status */
@@ -159,7 +159,7 @@ CU_Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini
 CU_Test(ddsc_entity_status, subscription_matched, .init=init_entity_status, .fini=fini_entity_status)
 {
     /* We're interested in subscription matched status. */
-    ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for subscription  matched status */
@@ -209,11 +209,11 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Get reader and writer status conditions and attach to waitset */
-    ret = dds_set_enabled_status(rea, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
+    ret = dds_set_status_mask(rea, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(reader2, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
+    ret = dds_set_status_mask(reader2, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(wri, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS);
+    ret = dds_set_status_mask(wri, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for subscription requested incompatible status, which should only be
@@ -253,16 +253,16 @@ CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_enti
 
 CU_Test(ddsc_entity, liveliness_changed, .init=init_entity_status, .fini=fini_entity_status)
 {
-    uint32_t set_status = 0;
+    uint32_t set_mask = 0;
     dds_liveliness_changed_status_t liveliness_changed;
 
-    ret = dds_set_enabled_status(rea, DDS_LIVELINESS_CHANGED_STATUS);
+    ret = dds_set_status_mask(rea, DDS_LIVELINESS_CHANGED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Get the status set */
-    ret = dds_get_enabled_status (rea, &set_status);
+    ret = dds_get_status_mask (rea, &set_mask);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    CU_ASSERT_EQUAL_FATAL(set_status, DDS_LIVELINESS_CHANGED_STATUS);
+    CU_ASSERT_EQUAL_FATAL(set_mask, DDS_LIVELINESS_CHANGED_STATUS);
 
     /* wait for LIVELINESS_CHANGED status */
     ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout);
@@ -307,9 +307,9 @@ CU_Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entit
     memset (&sample_rejected, 0, sizeof (sample_rejected));
     memset (&sample, 0, sizeof (sample));
 
-    ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(wri, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_REJECTED_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_REJECTED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for subscription matched and publication matched */
@@ -318,7 +318,7 @@ CU_Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entit
     ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout);
     CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize);
 
-    ret = dds_set_enabled_status(rea, DDS_SAMPLE_REJECTED_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SAMPLE_REJECTED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* write data - write more than resource limits set by a data reader */
@@ -354,32 +354,32 @@ Test(ddsc_entity, inconsistent_topic)
     cr_assert_gt(top, 0, "fails %d", dds_err_nr(top));
 
     /*Set reader topic and writer topic statuses enabled*/
-    ret = dds_set_enabled_status(top, DDS_INCONSISTENT_TOPIC_STATUS);
+    ret = dds_set_status_mask(top, DDS_INCONSISTENT_TOPIC_STATUS);
     cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(top, DDS_INCONSISTENT_TOPIC_STATUS);
+    ret = dds_set_status_mask(top, DDS_INCONSISTENT_TOPIC_STATUS);
     cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK);
 
     /* Wait for pub inconsistent topic status callback */
     ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout);
-    cr_assert_eq(ret, (dds_return_t)wsresultsize);
+    CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize);
     ret = dds_get_inconsistent_topic_status (top, &topic_status);
     cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK);
     cr_assert_gt(topic_status.total_count, 0);
 
     /*Getting the status should have reset the trigger, waitset should timeout */
     status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
-    cr_assert_eq(dds_err_nr(status), 0, "returned %d", dds_err_nr(status));
+    CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0, "returned %d", dds_err_nr(status));
 
     /* Wait for sub inconsistent topic status callback */
     ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout);
-    cr_assert_eq(status, wsresultsize);
+    CU_ASSERT_EQUAL_FATAL(status, wsresultsize);
     ret = dds_get_inconsistent_topic_status (top, &topic_status);
     cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK);
     cr_assert_gt(topic_status.total_count, 0);
 
     /*Getting the status should have reset the trigger, waitset should timeout */
     status = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout);
-    cr_assert_eq(dds_err_nr(status), 0, "returned %d", dds_err_nr(status));
+    CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), 0);
 
     dds_delete(top);
 }
@@ -395,9 +395,9 @@ CU_Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_st
     memset (&sample_lost, 0, sizeof (sample_lost));
     memset (&sample, 0, sizeof (sample));
 
-    ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(wri, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for subscription matched and publication matched */
@@ -406,7 +406,7 @@ CU_Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_st
     ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout);
     CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize);
 
-    ret = dds_set_enabled_status(rea, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* get current time - subtraction ensures that this is truly historic on all platforms. */
@@ -438,9 +438,9 @@ CU_Test(ddsc_entity, data_available, .init=init_entity_status, .fini=fini_entity
     RoundTripModule_DataType sample;
     memset (&sample, 0, sizeof (sample));
 
-    ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(wri, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Wait for subscription and publication matched status */
@@ -492,11 +492,11 @@ CU_Test(ddsc_entity, all_data_available, .init=init_entity_status, .fini=fini_en
     reader2 = dds_create_reader(subscriber, top, NULL, NULL);
     CU_ASSERT_FATAL(reader2 > 0);
 
-    ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(wri, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
+    ret = dds_set_status_mask(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(reader2, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
+    ret = dds_set_status_mask(reader2, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     waitSetrd2 = dds_create_waitset(participant);
@@ -591,25 +591,25 @@ CU_TheoryDataPoints(ddsc_get_enabled_status, bad_param) = {
 };
 CU_Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param)
 {
-    uint32_t status;
+    uint32_t mask;
     dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
 
-    ret = dds_get_enabled_status(e, &status);
+    ret = dds_get_status_mask(e, &mask);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
 }
 
 CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
 {
-    uint32_t status;
+    uint32_t mask;
     dds_delete(rea);
-    ret = dds_get_enabled_status(rea, &status);
+    ret = dds_get_status_mask(rea, &mask);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
 }
 
 CU_Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
 {
-    uint32_t status;
+    uint32_t mask;
-    ret = dds_get_enabled_status(waitSetrd, &status);
+    ret = dds_get_status_mask(waitSetrd, &mask);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
 }
 
@@ -618,8 +618,8 @@ CU_TheoryDataPoints(ddsc_get_enabled_status, status_ok) = {
 };
 CU_Theory((dds_entity_t *e), ddsc_get_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status)
 {
-    uint32_t status;
+    uint32_t mask;
-    ret = dds_get_enabled_status (*e, &status);
+    ret = dds_get_status_mask (*e, &mask);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 }
 /*************************************************************************************************/
@@ -632,20 +632,20 @@ CU_Theory((dds_entity_t e), ddsc_set_enabled_status, bad_param)
 {
     dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1;
 
-    ret = dds_set_enabled_status(e, 0 /*mask*/);
+    ret = dds_set_status_mask(e, 0 /*mask*/);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp));
 }
 
 CU_Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status)
 {
     dds_delete(rea);
-    ret = dds_set_enabled_status(rea, 0 /*mask*/);
+    ret = dds_set_status_mask(rea, 0 /*mask*/);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED);
 }
 
 CU_Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status)
 {
-    ret = dds_set_enabled_status(waitSetrd, 0);
+    ret = dds_set_status_mask(waitSetrd, 0);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION);
 }
 
@@ -654,7 +654,7 @@ CU_TheoryDataPoints(ddsc_set_enabled_status, status_ok) = {
 };
 CU_Theory((dds_entity_t *entity), ddsc_set_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status)
 {
-    ret = dds_set_enabled_status (*entity, 0);
+    ret = dds_set_status_mask (*entity, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 }
 /*************************************************************************************************/
@@ -846,7 +846,7 @@ CU_Theory((dds_entity_t topic), ddsc_get_inconsistent_topic_status, bad_params)
 /*************************************************************************************************/
 CU_Test(ddsc_get_inconsistent_topic_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(top, 0);
+    dds_set_status_mask(top, 0);
     ret = dds_get_inconsistent_topic_status(top, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -889,7 +889,7 @@ CU_Theory((dds_entity_t writer), ddsc_get_publication_matched_status, bad_params
 /*************************************************************************************************/
 CU_Test(ddsc_get_publication_matched_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(wri, 0);
+    dds_set_status_mask(wri, 0);
     ret = dds_get_publication_matched_status(wri, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -943,7 +943,7 @@ CU_Theory((dds_entity_t writer), ddsc_get_liveliness_lost_status, bad_params)
 /*************************************************************************************************/
 CU_Test(ddsc_get_liveliness_lost_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(wri, 0);
+    dds_set_status_mask(wri, 0);
     ret = dds_get_liveliness_lost_status(wri, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -998,7 +998,7 @@ CU_Theory((dds_entity_t writer), ddsc_get_offered_deadline_missed_status, bad_pa
 /*************************************************************************************************/
 CU_Test(ddsc_get_offered_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(wri, 0);
+    dds_set_status_mask(wri, 0);
     ret = dds_get_offered_deadline_missed_status(wri, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1041,7 +1041,7 @@ CU_Theory((dds_entity_t writer), ddsc_get_offered_incompatible_qos_status, bad_p
 /*************************************************************************************************/
 CU_Test(ddsc_get_offered_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(wri, 0);
+    dds_set_status_mask(wri, 0);
     ret = dds_get_offered_incompatible_qos_status(wri, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1084,7 +1084,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_subscription_matched_status, bad_param
 /*************************************************************************************************/
 CU_Test(ddsc_get_subscription_matched_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_subscription_matched_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1127,7 +1127,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_liveliness_changed_status, bad_params)
 /*************************************************************************************************/
 CU_Test(ddsc_get_liveliness_changed_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_liveliness_changed_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1170,7 +1170,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_sample_rejected_status, bad_params)
 /*************************************************************************************************/
 CU_Test(ddsc_get_sample_rejected_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_sample_rejected_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1213,7 +1213,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_sample_lost_status, bad_params)
 /*************************************************************************************************/
 CU_Test(ddsc_get_sample_lost_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_sample_lost_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1268,7 +1268,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_requested_deadline_missed_status, bad_
 /*************************************************************************************************/
 CU_Test(ddsc_get_requested_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_requested_deadline_missed_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }
@@ -1311,7 +1311,7 @@ CU_Theory((dds_entity_t reader), ddsc_get_requested_incompatible_qos_status, bad
 /*************************************************************************************************/
 CU_Test(ddsc_get_requested_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status)
 {
-    dds_set_enabled_status(rea, 0);
+    dds_set_status_mask(rea, 0);
     ret = dds_get_requested_incompatible_qos_status(rea, NULL);
     CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK);
 }

src/core/ddsc/tests/querycondition.c

@@ -103,7 +103,7 @@ querycondition_init(void)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -114,7 +114,7 @@ querycondition_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/read_instance.c

@@ -120,7 +120,7 @@ read_instance_init(void)
     CU_ASSERT_FATAL(g_qcond > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -131,7 +131,7 @@ read_instance_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/readcondition.c

@@ -96,7 +96,7 @@ readcondition_init(void)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -107,7 +107,7 @@ readcondition_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/reader.c

@@ -105,7 +105,7 @@ reader_init(void)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -116,7 +116,7 @@ reader_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -2481,7 +2481,7 @@ CU_Test(ddsc_take_mask, take_instance_last_sample)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -2492,7 +2492,7 @@ CU_Test(ddsc_take_mask, take_instance_last_sample)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/reader_iterator.c

@@ -160,7 +160,7 @@ reader_iterator_init(void)
     CU_ASSERT_FATAL(g_qcond > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -171,7 +171,7 @@ reader_iterator_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/register.c

@@ -82,7 +82,7 @@ registering_init(void)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -93,7 +93,7 @@ registering_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -203,8 +203,8 @@ CU_Test(ddsc_register_instance, registering_new_instance, .init=registering_init
     CU_ASSERT_EQUAL_FATAL(instHndl, DDS_HANDLE_NIL);
     ret = dds_register_instance(g_writer, &instHndl2, &newInstance);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    CU_ASSERT_EQUAL_FATAL(instHndl, instHndl2);
     instHndl = dds_lookup_instance(g_writer, &newInstance);
+    CU_ASSERT_EQUAL_FATAL(instHndl, instHndl2);
 }
 
 CU_Test(ddsc_register_instance, data_already_available, .init=registering_init, .fini=registering_fini)
@@ -217,4 +217,3 @@ CU_Test(ddsc_register_instance, data_already_available, .init=registering_init,
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     CU_ASSERT_EQUAL_FATAL(instHndl2, instHndl);
 }
-

src/core/ddsc/tests/take_instance.c

@@ -121,7 +121,7 @@ take_instance_init(void)
     CU_ASSERT_FATAL(g_qcond > 0);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -132,7 +132,7 @@ take_instance_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/unregister.c

@@ -82,7 +82,7 @@ unregistering_init(void)
     CU_ASSERT_FATAL(g_writer > 0);
 
     /* Sync g_writer to g_reader. */
-    ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_writer, DDS_PUBLICATION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_writer, g_writer);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -93,7 +93,7 @@ unregistering_init(void)
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Sync g_reader to g_writer. */
-    ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -332,7 +332,7 @@ CU_Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregister
     dds_return_t ret;
 
     /* Unregistering a sample in the past should trigger a lost sample. */
-    ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
@@ -572,7 +572,7 @@ CU_Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregis
     dds_return_t ret;
 
     /* Unregistering a sample in the past should trigger a lost sample. */
-    ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS);
+    ret = dds_set_status_mask(g_reader, DDS_SAMPLE_LOST_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
     ret = dds_waitset_attach(g_waitset, g_reader, g_reader);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);

src/core/ddsc/tests/waitset.c

@@ -139,17 +139,17 @@ ddsc_waitset_attached_init(void)
     ddsc_waitset_init();
 
     /* Start with interest in nothing. */
-    ret = dds_set_enabled_status(participant, 0);
+    ret = dds_set_status_mask(participant, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(writer, 0);
+    ret = dds_set_status_mask(writer, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(reader, 0);
+    ret = dds_set_status_mask(reader, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(topic, 0);
+    ret = dds_set_status_mask(topic, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(publisher, 0);
+    ret = dds_set_status_mask(publisher, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
-    ret = dds_set_enabled_status(subscriber, 0);
+    ret = dds_set_status_mask(subscriber, 0);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* Attach all entities to the waitset. */
@@ -952,7 +952,7 @@ CU_Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .f
     memset(&sample, 0, sizeof(RoundTripModule_DataType));
 
     /* Only interested in data_available for this test. */
-    ret = dds_set_enabled_status(reader, DDS_DATA_AVAILABLE_STATUS);
+    ret = dds_set_status_mask(reader, DDS_DATA_AVAILABLE_STATUS);
     CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK);
 
     /* The reader should not have been triggered. */

src/docs/GettingStartedGuide/helloworld_indepth.rst

@@ -395,7 +395,7 @@ To make this happen, the writer must be instructed to 'listen' for this status.
 The following line of code makes sure the writer does so.
 ::
 
-    dds_set_enabled_status(writer, DDS_PUBLICATION_MATCHED_STATUS);
+    dds_set_status_mask(writer, DDS_PUBLICATION_MATCHED_STATUS);
 
 Now the polling may start:
 ::

src/examples/helloworld/publisher.c

@@ -27,7 +27,7 @@ int main (int argc, char ** argv)
 
     printf("=== [Publisher]  Waiting for a reader to be discovered ...\n");
 
-    ret = dds_set_enabled_status(writer, DDS_PUBLICATION_MATCHED_STATUS);
+    ret = dds_set_status_mask(writer, DDS_PUBLICATION_MATCHED_STATUS);
     DDS_ERR_CHECK (ret, DDS_CHECK_REPORT | DDS_CHECK_EXIT);
 
     while(true)

src/examples/throughput/publisher.c

@@ -200,7 +200,7 @@ static dds_return_t wait_for_reader(dds_entity_t writer, dds_entity_t participan
   dds_return_t ret;
   dds_entity_t waitset;
 
-  ret = dds_set_enabled_status(writer, DDS_PUBLICATION_MATCHED_STATUS);
+  ret = dds_set_status_mask(writer, DDS_PUBLICATION_MATCHED_STATUS);
   DDS_ERR_CHECK (ret, DDS_CHECK_REPORT | DDS_CHECK_EXIT);
 
   waitset = dds_create_waitset(participant);

src/examples/throughput/subscriber.c

@@ -122,7 +122,7 @@ int main (int argc, char **argv)
   process_samples(maxCycles);
 
   /* Finished, disable callbacks */
-  dds_set_enabled_status (reader, 0);
+  dds_set_status_mask (reader, 0);
   HandleMap__free (imap);
 
 #ifdef _WIN32

src/tools/pubsub/pubsub.c

@@ -1660,8 +1660,8 @@ static uint32_t subthread(void *vspec) {
     case MODE_DUMP:
         if (!spec->polling) {
             /* fastest trigger we have */
-            rc = dds_set_enabled_status(rd, DDS_DATA_AVAILABLE_STATUS);
+            rc = dds_set_status_mask(rd, DDS_DATA_AVAILABLE_STATUS);
-            error_abort(rc, "dds_set_enabled_status(stcond)");
+            error_abort(rc, "dds_set_status_mask(stcond)");
             rc = dds_waitset_attach(ws, rd, rd);
             error_abort(rc, "dds_waitset_attach(rd)");
             nxs++;