DDS_ReturnCode_t DDS_DomainParticipant_delete_contained_entities (DDS_DomainParticipant dp)
{
Publisher_t *up;
Subscriber_t *sp;
Condition_t *cp;
DDS_ReturnCode_t ret;
ctrc_printd (DCPS_ID, DCPS_DP_D_CONT, &dp, sizeof (dp));
if (!domain_ptr (dp, 1, &ret))
return (ret);
while ((up = dp->publishers.head) != NULL) {
delete_publisher_entities (dp, up);
if (up->nwriters != 0) {
lock_release (dp->lock);
return (DDS_RETCODE_PRECONDITION_NOT_MET);
}
dtrc_printf ("participant_delete_contained_entitities: delete Publisher (%p)\r\n", (void *) up);
qos_publisher_free (&up->qos);
if (up->condition) {
cp = (Condition_t *) up->condition;
if (cp->deferred)
dds_defer_waitset_undo (up, up->condition);
dcps_delete_status_condition (up->condition);
}
publisher_delete (up);
}
while ((sp = dp->subscribers.head) != NULL) {
delete_subscriber_entities (dp, sp);
if (sp->nreaders != 0) {
lock_release (dp->lock);
return (DDS_RETCODE_PRECONDITION_NOT_MET);
}
dtrc_printf ("participant_delete_contained_entitities: delete Subscriber (%p)\r\n", (void *) sp);
qos_subscriber_free (&sp->qos);
if (sp->condition) {
cp = (Condition_t *) sp->condition;
if (cp->deferred)
dds_defer_waitset_undo (sp, sp->condition);
dcps_delete_status_condition (sp->condition);
}
subscriber_delete (sp);
}
sl_walk (&dp->participant.p_topics, dcps_delete_topic, dp);
sl_walk (&dp->types, delete_type, dp);
lock_release (dp->lock);
return (DDS_RETCODE_OK);
}
DDS_ReturnCode_t DDS_Subscriber_set_qos (DDS_Subscriber sp,
DDS_SubscriberQos *qos)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_printd (DCPS_ID, DCPS_S_S_QOS, &sp, sizeof (sp));
ctrc_contd (&qos, sizeof (qos));
ctrc_endd ();
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = domain_ptr (sp->domain, 1, &ret);
if (!dp)
return (ret);
if (qos == DDS_PUBLISHER_QOS_DEFAULT)
qos = &sp->domain->def_subscriber_qos;
else if (!qos_valid_subscriber_qos (qos)) {
ret = DDS_RETCODE_BAD_PARAMETER;
goto done;
}
ret = qos_subscriber_update (&sp->qos, qos);
if (ret == DDS_RETCODE_OK)
sl_walk (&sp->domain->participant.p_endpoints, update_reader_qos, sp);
done:
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_delete_typesupport (DDS_DomainParticipant dp,
DDS_TypeSupport ts)
{
struct type_sup_rem_state_st state;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_D_TS, &p, sizeof (p));
ctrc_contd (&ts, sizeof (ts));
ctrc_endd ();
/* Validate some required arguments. */
if (!ts)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
/* Search type name in participant type list. */
state.part = dp;
state.ts = ts;
state.ret = DDS_RETCODE_ALREADY_DELETED;
sl_walk (&dp->types, delete_type_support, &state);
lock_release (dp->lock);
return (state.ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_get_discovered_topics (DDS_DomainParticipant dp,
DDS_InstanceHandleSeq *handles)
{
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_G_DISC_T_S, &dp, sizeof (dp));
ctrc_contd (&handles, sizeof (handles));
ctrc_endd ();
if (!handles)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
DDS_SEQ_INIT (*handles);
if ((dp->participant.p_flags & EF_ENABLED) == 0) {
lock_release (dp->lock);
return (DDS_RETCODE_NOT_ENABLED);
}
sl_walk (&dp->participant.p_topics, topic_add_handle, handles);
lock_release (dp->lock);
return (ret);
}
int rtps_trace_set (Endpoint_t *r, unsigned mode)
{
Domain_t *dp;
ENDPOINT *ep;
unsigned index;
if (r == DDS_TRACE_ALL_ENDPOINTS) {
index = 0;
for (;;) {
dp = domain_next (&index, NULL);
if (!dp)
break;
sl_walk (&dp->participant.p_endpoints, trace_set_fct, &mode);
}
return (DDS_RETCODE_OK);
}
ep = r->rtps;
if (!ep)
return (DDS_RETCODE_OK);
if (mode == DDS_TRACE_MODE_TOGGLE) {
if (ep->trace_frames || ep->trace_sigs ||
ep->trace_tmr || ep->trace_state)
mode = 0;
else
mode = DDS_TRACE_ALL;
}
ep->trace_frames = mode & DDS_RTRC_FTRACE;
ep->trace_sigs = mode & DDS_RTRC_STRACE;
ep->trace_tmr = mode & DDS_RTRC_ETRACE;
ep->trace_state = mode & DDS_RTRC_TTRACE;
return (DDS_RETCODE_OK);
}
static void type_promote_tc (Domain_t *dp,
TopicType_t *typep,
const TypeSupport_t *ts,
unsigned char *tc)
{
TPTC_t tptc;
tptc.type = typep;
tptc.ts = ts;
tptc.eq_tc = tc;
tptc.ntopics = typep->nrefs;
sl_walk (&dp->participant.p_topics, topic_type_promote_tc_fct, &tptc);
}
void dcps_endpoints_dump (void)
{
Domain_t *dp;
unsigned n, i = 0;
n = domain_count ();
while ((dp = domain_next (&i, NULL)) != NULL) {
if (n > 1) {
dbg_print_guid_prefix (&dp->participant.p_guid_prefix);
dbg_printf (":\r\n");
}
sl_walk (&dp->participant.p_endpoints,
ep_dump_fct,
&dp->domain_id);
}
}
DDS_ReturnCode_t DDS_Subscriber_notify_datareaders (DDS_Subscriber sp)
{
Domain_t *dp;
DDS_ReturnCode_t ret;
ctrc_printd (DCPS_ID, DCPS_S_NOTIF_DR, &sp, sizeof (sp));
if (!subscriber_ptr (sp, &ret))
return (ret);
dp = sp->domain;
if (!dp || lock_take (dp->lock))
return (DDS_RETCODE_ALREADY_DELETED);
sl_walk (&dp->participant.p_endpoints,
subscriber_notify_reader,
sp);
lock_release (dp->lock);
return (ret);
}
DDS_ReturnCode_t DDS_Subscriber_get_datareaders (DDS_Subscriber sp,
DDS_DataReaderSeq *readers,
DDS_SampleStateMask sample_states,
DDS_ViewStateMask view_states,
DDS_InstanceStateMask instance_states)
{
Domain_t *dp;
SubGReaders_t srd;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_S_G_DR_S, &sp, sizeof (sp));
ctrc_contd (&readers, sizeof (readers));
ctrc_contd (&sample_states, sizeof (sample_states));
ctrc_contd (&view_states, sizeof (view_states));
ctrc_contd (&instance_states, sizeof (instance_states));
ctrc_endd ();
if (!readers)
return (DDS_RETCODE_BAD_PARAMETER);
srd.sp = subscriber_ptr (sp, &ret);
if (!srd.sp)
return (ret);
DDS_SEQ_INIT (*readers);
srd.rseq = readers;
srd.skip = dcps_skip_mask (sample_states, view_states, instance_states);
srd.ret = DDS_RETCODE_OK;
dp = srd.sp->domain;
if (!dp || lock_take (dp->lock))
return (DDS_RETCODE_ALREADY_DELETED);
sl_walk (&dp->participant.p_endpoints,
subscriber_get_reader,
&srd);
lock_release (dp->lock);
return (srd.ret);
}
DDS_ReturnCode_t DDS_DomainParticipant_unregister_type (DDS_DomainParticipant dp,
DDS_TypeSupport ts,
const char *type_name)
{
TopicType_t *typep;
struct type_lookup_st lookup;
DDS_ReturnCode_t ret;
ctrc_begind (DCPS_ID, DCPS_DP_U_TYPE, &dp, sizeof (dp));
ctrc_contd (&ts, sizeof (ts));
ctrc_contd (type_name, strlen (type_name));
ctrc_endd ();
prof_start (dcps_unreg_type);
/* Validate some required arguments. */
if (!ts)
return (DDS_RETCODE_BAD_PARAMETER);
if (!domain_ptr (dp, 1, &ret))
return (ret);
/* Search type name in participant type list. */
typep = type_lookup (dp, type_name);
if (!typep ||
#if !defined DDS_TYPECODE
typep->type_support != ts ||
#endif
(typep->flags & EF_LOCAL) == 0) {
lock_release (dp->lock);
return (DDS_RETCODE_ALREADY_DELETED);
}
/* Type exists and is locally created.
Check if there are local topics that are still using the type. */
lookup.type = typep;
lookup.nusers = 0;
sl_walk (&dp->participant.p_topics, topic_type_check_fct, &lookup);
if (lookup.nusers) {
if (typep->nrefs > lookup.nusers + 1) {
ret = DDS_RETCODE_OK;
typep->nrefs--;
if (--typep->nlrefs == 0) {
typep->flags &= ~EF_LOCAL;
DDS_TypeSupport_delete(typep->type_support);
}
}
else
ret = DDS_RETCODE_PRECONDITION_NOT_MET;
lock_release (dp->lock); /* Still in use! */
return (ret);
}
if (--typep->nlrefs == 0) {
typep->flags &= ~EF_LOCAL;
DDS_TypeSupport_delete(typep->type_support);
typep->type_support = NULL;
}
type_delete (dp, typep);
lock_release (dp->lock);
prof_stop (dcps_unreg_type, 1);
return (DDS_RETCODE_OK);
}
