C++ ctrc_contd函数代码示例

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_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_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_DataWriter_dispose (DDS_DataWriter             wp,
					 const void                 *data,
					 const DDS_InstanceHandle_t handle)
{
	FTime_t	time;

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

	sys_getftime (&time);
	return (dcps_dispose (wp, data, 0, handle, &time, NULL));
}

DDS_InstanceHandle_t DDS_DataWriter_register_instance_w_timestamp (
					DDS_DataWriter   wp,
					const void       *data,
					const DDS_Time_t *time)
{
	FTime_t	ftime;

	ctrc_begind (DCPS_ID, DCPS_DW_R_INST_TS, &wp, sizeof (wp));
	ctrc_contd (&data, sizeof (data));
	ctrc_contd (time, sizeof (*time));
	ctrc_endd ();

	FTIME_SET (ftime, time->sec, time->nanosec);
	return (dcps_register_instance (wp, data, 0, &ftime));
}

int trc_lock_destroy (pthread_mutex_t *l, const char *file, int line)
{
	LockState_t	*lp, *prev_lp;
	unsigned	h;
	int		res;

	ARG_NOT_USED (file)
	ARG_NOT_USED (line)

	lock_takef (trc_lock);
	h = lock_hash (l);
	for (prev_lp = NULL, lp = locks [h];
	     lp && lp->lock != l;
	     prev_lp = lp, lp = lp->next)
		;

	if (lp) {
		ltrc_print1 ("{Destroy(%s)", lp->name);
		if (prev_lp)
			prev_lp->next = lp->next;
		else
			locks [h] = lp->next;
	}
#ifdef LOG_LOCKS
	else
		ltrc_print1 ("{Destroy(%p)", (void *) l);
#endif
	ltrc_print1 ("%c}", '!');
#ifdef CTRC_LOCKS
	if (ctrace_used) {
		ctrc_begind (THREAD_ID, LOCK_DESTROY, &l, sizeof (l));
		if (lp && lp->name)
			ctrc_contd (lp->name, strlen (lp->name) + 1);
		ctrc_contd (file, strlen (file) + 1);
		ctrc_contd (&line, sizeof (line));
		ctrc_endd ();
	}
#endif
	res = pthread_mutex_destroy (l);
	if (res)
		warn_printf ("trc_lock_destroy: pthread_mutex_destroy(%s) returned error: %s",
			(lp) ? lp->name : NULL, strerror (res));

	if (lp)
		Free (lp);
	lock_releasef (trc_lock);
	return (res);
}

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