C++ ctrc_endd函数代码示例

DDS_ReturnCode_t DDS_DomainParticipant_ignore_publication (DDS_DomainParticipant dp,
						           DDS_InstanceHandle_t handle)
{
	Entity_t		*ep;
	DDS_ReturnCode_t	ret;

	ctrc_begind (DCPS_ID, DCPS_DP_IGN_PUB, &dp, sizeof (dp));
	ctrc_contd (&handle, sizeof (handle));
	ctrc_endd ();

	if (!domain_ptr (dp, 1, &ret))
		return (ret);

	if ((dp->participant.p_flags & EF_ENABLED) == 0) {
		lock_release (dp->lock);
		return (DDS_RETCODE_NOT_ENABLED);
	}
	ep = entity_ptr (handle);
	if (!ep ||
	    ep->type != ET_WRITER ||
	    !entity_discovered (ep->flags)) {
		ret = DDS_RETCODE_ALREADY_DELETED;
		goto done;
	}
	ret = disc_ignore_writer ((DiscoveredWriter_t *) ep);

    done:
	lock_release (dp->lock);
	return (ret);
}

DDS_ReturnCode_t DDS_Subscriber_set_default_datareader_qos (DDS_Subscriber sp,
							    DDS_DataReaderQos *qos)
{
	Domain_t	 *dp;
	DDS_ReturnCode_t ret;

	ctrc_begind (DCPS_ID, DCPS_S_S_DR_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_DATAREADER_QOS_DEFAULT)
		qos = (DDS_DataReaderQos *) &qos_def_reader_qos;
	else if (!qos_valid_reader_qos (qos)) {
		ret = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	sp->def_reader_qos = *qos;

    done:
    	lock_release (dp->lock);
	return (ret);
}

DDS_ReturnCode_t DDS_DomainParticipant_set_qos (DDS_DomainParticipant dp,
						DDS_DomainParticipantQos *qos)
{
	DDS_ReturnCode_t	ret;

	ctrc_begind (DCPS_ID, DCPS_DP_S_QOS, &dp, sizeof (dp));
	ctrc_contd (&qos, sizeof (qos));
	ctrc_endd ();

	if (!domain_ptr (dp, 1, &ret))
		return (ret);

	if (qos == DDS_PARTICIPANT_QOS_DEFAULT)
		qos = &dcps_def_participant_qos;
	else if (!qos_valid_participant_qos (qos)) {
		ret = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	if (dp->participant.p_user_data)
		str_unref (dp->participant.p_user_data);
	dp->participant.p_user_data = qos_octets2str (&qos->user_data.value);
	dp->autoenable = qos->entity_factory.autoenable_created_entities;
	if ((dp->participant.p_flags & EF_ENABLED) != 0)
		ret = disc_participant_update (dp);

    done:
	lock_release (dp->lock);
	return (ret);
}

DDS_ReturnCode_t DDS_DataWriter_set_qos (DDS_DataWriter wp,
					 DDS_DataWriterQos *qos)
{
	DDS_ReturnCode_t ret;

	ctrc_begind (DCPS_ID, DCPS_DW_S_QOS, &wp, sizeof (wp));
	ctrc_contd (&qos, sizeof (qos));
	ctrc_endd ();

	if (!writer_ptr (wp, 1, &ret))
		return (ret);

	if (qos == DDS_DATAWRITER_QOS_DEFAULT)
		qos = &wp->w_publisher->def_writer_qos;
	else if (!qos_valid_writer_qos (qos)) {
		ret = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	ret = qos_writer_update (&wp->w_qos, qos);

    done:
	lock_release (wp->w_lock);

	if (ret)
		return (ret);

	lock_take (wp->w_topic->domain->lock);
	dcps_update_writer_qos (NULL, &wp, wp->w_publisher);
	lock_release (wp->w_topic->domain->lock);

	return (ret);
}

DDS_MultiTopic DDS_DomainParticipant_create_multitopic (
				DDS_DomainParticipant dp,
				const char *name,
				const char *type_name,
				const char *subs_expr,
				DDS_StringSeq *expr_pars)
{
	ctrc_begind (DCPS_ID, DCPS_DP_C_MTOP, &dp, sizeof (dp));
	ctrc_contd (name, strlen (name) + 1);
	ctrc_contd (type_name, strlen (type_name) + 1);
	ctrc_contd (subs_expr, strlen (subs_expr) + 1);
	ctrc_contd (&expr_pars, sizeof (expr_pars));
	ctrc_endd ();

	ARG_NOT_USED (expr_pars)

	/* Check some required parameters. */
	if (!domain_ptr (dp, 0, NULL))
		return (NULL);

	if (!subs_expr || !name || !type_name)
		return (NULL);

	return (NULL);
}

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_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_DataWriter_get_matched_subscription_data (
				DDS_DataWriter                   wp,
				DDS_SubscriptionBuiltinTopicData *data,
				DDS_InstanceHandle_t             handle)
{
	Entity_t		*ep;
	DDS_ReturnCode_t	ret;

	ctrc_begind (DCPS_ID, DCPS_DW_G_SUBS_D, &wp, sizeof (wp));
	ctrc_contd (&data, sizeof (data));
	ctrc_contd (&handle, sizeof (handle));
	ctrc_endd ();

	if (!data || !handle)
		return (DDS_RETCODE_BAD_PARAMETER);

	if (!writer_ptr (wp, 1, &ret))
		return (ret);

	ep = entity_ptr (handle);
	if (!ep ||
	     ep->type != ET_READER ||
	     entity_ignored (ep->flags)) {
		ret = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	if (entity_discovered (ep->flags))
		ret = dcps_get_builtin_subscription_data (data, (DiscoveredReader_t *) ep);
	else
		ret = dcps_get_local_subscription_data (data, (Reader_t *) ep);

    done:
	lock_release (wp->w_lock);
	return (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);
}

DDS_ReturnCode_t DDS_Subscriber_set_listener (DDS_Subscriber sp,
					      DDS_SubscriberListener *listener,
					      DDS_StatusMask mask)
{
	Domain_t		*dp;
	DDS_ReturnCode_t	ret;

	ctrc_printd (DCPS_ID, DCPS_S_S_LIS, &sp, sizeof (sp));
	ctrc_contd (&listener, sizeof (listener));
	ctrc_contd (&mask, sizeof (mask));
	ctrc_endd ();

	if (!subscriber_ptr (sp, &ret))
		return (ret);

	dp = domain_ptr (sp->domain, 1, &ret);
	if (!dp)
		return (ret);

	dcps_update_listener ((Entity_t *) sp, &dp->lock,
			      &sp->mask, &sp->listener,
			      mask, listener);
	lock_release (dp->lock);
	return (DDS_RETCODE_OK);
}

DDS_ReturnCode_t DDS_Subscriber_get_default_datareader_qos (DDS_Subscriber sp,
							    DDS_DataReaderQos *qos)
{
	Domain_t	 *dp;
	DDS_ReturnCode_t ret;

	ctrc_begind (DCPS_ID, DCPS_S_G_DR_QOS, &sp, sizeof (sp));
	ctrc_contd (&qos, sizeof (qos));
	ctrc_endd ();

	if (!qos) {
		log_printf (DCPS_ID, 0, "get_default_datareader_qos: invalid parameters!\r\n");
		return (DDS_RETCODE_BAD_PARAMETER);
	}
	if (!subscriber_ptr (sp, &ret))
		return (ret);

	dp = domain_ptr (sp->domain, 1, &ret);
	if (!dp)
		return (ret);

	*qos = sp->def_reader_qos;
	lock_release (dp->lock);
	return (DDS_RETCODE_OK);
}

DDS_ReturnCode_t DDS_ContentFilteredTopic_set_expression_parameters (
						DDS_ContentFilteredTopic ftp,
						DDS_StringSeq *expr_pars)
{
	DDS_ReturnCode_t	rc;

	ctrc_begind (DCPS_ID, DCPS_FT_S_PARS, &ftp, sizeof (ftp));
	ctrc_contd (&expr_pars, sizeof (expr_pars));
	ctrc_endd ();

	if (!topic_ptr (ftp, 1, NULL))
		return (DDS_RETCODE_ALREADY_DELETED);

	if ((ftp->topic.entity.flags & EF_FILTERED) == 0) {
		rc = DDS_RETCODE_ALREADY_DELETED;
		goto done;
	}
	if (!expr_pars || DDS_SEQ_LENGTH (*expr_pars) < ftp->data.program.npars) {
		rc = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	rc = dcps_update_str_pars (&ftp->data.filter.expression_pars, expr_pars);

    done:
	lock_release (ftp->topic.lock);
	return (rc);
}

DDS_ReturnCode_t DDS_ContentFilteredTopic_get_expression_parameters (
						DDS_ContentFilteredTopic ftp,
						DDS_StringSeq *expr_pars)
{
	DDS_ReturnCode_t	rc;

	ctrc_begind (DCPS_ID, DCPS_FT_G_PARS, &ftp, sizeof (ftp));
	ctrc_contd (&expr_pars, sizeof (expr_pars));
	ctrc_endd ();

	if (!topic_ptr (ftp, 1, NULL))
		return (DDS_RETCODE_ALREADY_DELETED);

	if ((ftp->topic.entity.flags & EF_FILTERED) == 0) {
		lock_release (ftp->topic.lock);
		return (DDS_RETCODE_ALREADY_DELETED);
	}
	if (!expr_pars) {
		lock_release (ftp->topic.lock);
		return (DDS_RETCODE_BAD_PARAMETER);
	}
	DDS_SEQ_INIT (*expr_pars);
	rc = dcps_get_str_pars (expr_pars, ftp->data.filter.expression_pars);
	lock_release (ftp->topic.lock);
	return (rc);
}

DDS_ReturnCode_t DDS_DataWriter_get_matched_subscriptions(
					DDS_DataWriter        wp,
					DDS_InstanceHandleSeq *handles)
{
	Topic_t		*tp;
	Endpoint_t	*ep;
	FilteredTopic_t	*ftp;
	DDS_ReturnCode_t ret;

	ctrc_begind (DCPS_ID, DCPS_DW_G_MATCH_S, &wp, sizeof (wp));
	ctrc_contd (&handles, sizeof (handles));
	ctrc_endd ();

	if (!handles)
		return (DDS_RETCODE_BAD_PARAMETER);

	DDS_SEQ_INIT (*handles);
	if (!writer_ptr (wp, 0, &ret))
		return (ret);

	tp = wp->w_topic;
	if (lock_take (tp->lock))
		return (DDS_RETCODE_ALREADY_DELETED);

#ifndef RW_TOPIC_LOCK
	if (lock_take (wp->w_lock)) {
		lock_release (tp->lock);
		return (DDS_RETCODE_ALREADY_DELETED);
	}
#endif
	for (ep = tp->writers; ep && ep != &wp->w_ep; ep = ep->next)
		;
	if (!ep) {
		ret = DDS_RETCODE_ALREADY_DELETED;
		goto done;
	}
	for (ep = tp->readers; ep; ep = ep->next)
		if (check_matched_subscription (wp, ep, handles, NULL)) {
			ret = DDS_RETCODE_OUT_OF_RESOURCES;
			goto done;
		}

	for (ftp = tp->filters; ftp; ftp = ftp->next)
		for (ep = ftp->topic.readers; ep; ep = ep->next)
			if (check_matched_subscription (wp, ep, handles, NULL)) {
				ret = DDS_RETCODE_OUT_OF_RESOURCES;
				goto done;
			}

    done:
#ifndef RW_TOPIC_LOCK
	lock_release (wp->w_lock);
#endif
	lock_release (tp->lock);
	return (ret);
}

DDS_ReturnCode_t DDS_Topic_set_qos (DDS_Topic tp, DDS_TopicQos *qos)
{
	Endpoint_t		*ep;
	Reader_t		*rp;
	Writer_t		*wp;
	DDS_ReturnCode_t	ret;

	ctrc_begind (DCPS_ID, DCPS_T_S_QOS, &tp, sizeof (tp));
	ctrc_contd (&qos, sizeof (qos));
	ctrc_endd ();

	if (!topic_ptr (tp, 1, &ret))
		return (ret);

	if (qos == DDS_TOPIC_QOS_DEFAULT)
		qos = &tp->domain->def_topic_qos;
	else if (!qos_valid_topic_qos (qos)) {
		ret = DDS_RETCODE_BAD_PARAMETER;
		goto done;
	}
	ret = qos_topic_update (&tp->qos, qos);
	if (ret != DDS_RETCODE_OK)
		goto done;

	/* Update all local Readers associated with topic. */
	for (ep = tp->readers; ep; ep = ep->next)
		if ((ep->entity.flags & EF_LOCAL) != 0) {
			rp = (Reader_t *) ep;
#ifdef RW_LOCKS
			lock_take (rp->r_lock);
#endif
			disc_reader_update (tp->domain, rp, 1, 0);
#ifdef RW_LOCKS
			lock_release (rp->r_lock);
#endif
		}

	/* Update all local Writers associated with topic. */
	for (ep = tp->writers; ep; ep = ep->next)
		if ((ep->entity.flags & EF_LOCAL) != 0) {
			wp = (Writer_t *) ep;
#ifdef RW_LOCKS
			lock_take (wp->w_lock);
#endif
			disc_writer_update (tp->domain, wp, 1, 0);
#ifdef RW_LOCKS
			lock_release (wp->w_lock);
#endif
		}

    done:
    	lock_release (tp->lock);
	return (ret);
}