niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove QoS duplication between DDS and DDSI

Browse source 
All this duplication was rather useless: the values are standardized
anyway and the conversion was a simple type cast without any check.
This commit unifies the definitions.

* DDSI now uses the definitions of the various QoS "kind" values from
  the header file;

* The durations in the QoS objects are no longer in wire-format
  representation, the conversions now happen only in conversion to/from
  wire format;

* The core DDSI stack no longer uses DDSI time representations for time
  stamps, instead using the "native" one;

* QoS policy ids duplication has been eliminated, again using the IDs
  visible in the API -- the actual values are meaningless to the DDSI
  stack anyway.

Signed-off-by: Erik Boasson <eb@ilities.com>
This commit is contained in:
Erik Boasson 2019-05-26 12:12:00 +02:00 • committed by eboasson
parent 13480616e0
commit 12e6946163
38 changed files with 1074 additions and 1242 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/core/ddsc/CMakeLists.txt
View file

@ -46,6 +46,7 @@ PREPEND(hdrs_public_ddsc "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include/dd
ddsc/dds_public_impl.h
ddsc/dds_public_listener.h
ddsc/dds_public_qos.h
ddsc/dds_public_qosdefs.h
ddsc/dds_public_status.h
)

2
src/core/ddsc/include/dds/ddsc/dds_public_impl.h
View file

@ -39,8 +39,6 @@ typedef struct dds_sequence
}
dds_sequence_t;
#define DDS_LENGTH_UNLIMITED -1
typedef struct dds_key_descriptor
{
const char * m_name;

121
src/core/ddsc/include/dds/ddsc/dds_public_qos.h
View file

@ -21,131 +21,12 @@
#define DDS_QOS_H
#include "dds/export.h"
#include "dds/ddsc/dds_public_qosdefs.h"
#if defined (__cplusplus)
extern "C" {
#endif
/* QoS identifiers */
/** @name QoS identifiers
@{**/
#define DDS_INVALID_QOS_POLICY_ID 0
#define DDS_USERDATA_QOS_POLICY_ID 1
#define DDS_DURABILITY_QOS_POLICY_ID 2
#define DDS_PRESENTATION_QOS_POLICY_ID 3
#define DDS_DEADLINE_QOS_POLICY_ID 4
#define DDS_LATENCYBUDGET_QOS_POLICY_ID 5
#define DDS_OWNERSHIP_QOS_POLICY_ID 6
#define DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID 7
#define DDS_LIVELINESS_QOS_POLICY_ID 8
#define DDS_TIMEBASEDFILTER_QOS_POLICY_ID 9
#define DDS_PARTITION_QOS_POLICY_ID 10
#define DDS_RELIABILITY_QOS_POLICY_ID 11
#define DDS_DESTINATIONORDER_QOS_POLICY_ID 12
#define DDS_HISTORY_QOS_POLICY_ID 13
#define DDS_RESOURCELIMITS_QOS_POLICY_ID 14
#define DDS_ENTITYFACTORY_QOS_POLICY_ID 15
#define DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID 16
#define DDS_READERDATALIFECYCLE_QOS_POLICY_ID 17
#define DDS_TOPICDATA_QOS_POLICY_ID 18
#define DDS_GROUPDATA_QOS_POLICY_ID 19
#define DDS_TRANSPORTPRIORITY_QOS_POLICY_ID 20
#define DDS_LIFESPAN_QOS_POLICY_ID 21
#define DDS_DURABILITYSERVICE_QOS_POLICY_ID 22
/** @}*/
/* QoS structure is opaque */
/** QoS structure */
typedef struct nn_xqos dds_qos_t;
/** Durability QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_durability_kind
{
DDS_DURABILITY_VOLATILE,
DDS_DURABILITY_TRANSIENT_LOCAL,
DDS_DURABILITY_TRANSIENT,
DDS_DURABILITY_PERSISTENT
}
dds_durability_kind_t;
/** History QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_history_kind
{
DDS_HISTORY_KEEP_LAST,
DDS_HISTORY_KEEP_ALL
}
dds_history_kind_t;
/** Ownership QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_ownership_kind
{
DDS_OWNERSHIP_SHARED,
DDS_OWNERSHIP_EXCLUSIVE
}
dds_ownership_kind_t;
/** Liveliness QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_liveliness_kind
{
DDS_LIVELINESS_AUTOMATIC,
DDS_LIVELINESS_MANUAL_BY_PARTICIPANT,
DDS_LIVELINESS_MANUAL_BY_TOPIC
}
dds_liveliness_kind_t;
/** Reliability QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_reliability_kind
{
DDS_RELIABILITY_BEST_EFFORT,
DDS_RELIABILITY_RELIABLE
}
dds_reliability_kind_t;
/** DestinationOrder QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_destination_order_kind
{
DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP,
DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP
}
dds_destination_order_kind_t;
/** History QoS: Applies to Topic, DataReader, DataWriter */
typedef struct dds_history_qospolicy
{
dds_history_kind_t kind;
int32_t depth;
}
dds_history_qospolicy_t;
/** ResourceLimits QoS: Applies to Topic, DataReader, DataWriter */
typedef struct dds_resource_limits_qospolicy
{
int32_t max_samples;
int32_t max_instances;
int32_t max_samples_per_instance;
}
dds_resource_limits_qospolicy_t;
/** Presentation QoS: Applies to Publisher, Subscriber */
typedef enum dds_presentation_access_scope_kind
{
DDS_PRESENTATION_INSTANCE,
DDS_PRESENTATION_TOPIC,
DDS_PRESENTATION_GROUP
}
dds_presentation_access_scope_kind_t;
/** Ignore-local QoS: Applies to DataReader, DataWriter */
typedef enum dds_ignorelocal_kind
{
DDS_IGNORELOCAL_NONE,
DDS_IGNORELOCAL_PARTICIPANT,
DDS_IGNORELOCAL_PROCESS
}
dds_ignorelocal_kind_t;
/**
* @brief Allocate memory and initialize default QoS-policies
*

132
src/core/ddsc/include/dds/ddsc/dds_public_qosdefs.h Normal file
View file

@ -0,0 +1,132 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
/** @file
*
* @brief DDS C QoS API
*
* This header file defines the public API of QoS and Policies in the
* Eclipse Cyclone DDS C language binding.
*/
#ifndef DDS_QOSDEFS_H
#define DDS_QOSDEFS_H
#if defined (__cplusplus)
extern "C" {
#endif
#define DDS_LENGTH_UNLIMITED -1
/** QoS identifiers */
typedef enum dds_qos_policy_id {
DDS_INVALID_QOS_POLICY_ID,
DDS_USERDATA_QOS_POLICY_ID,
DDS_DURABILITY_QOS_POLICY_ID,
DDS_PRESENTATION_QOS_POLICY_ID,
DDS_DEADLINE_QOS_POLICY_ID,
DDS_LATENCYBUDGET_QOS_POLICY_ID,
DDS_OWNERSHIP_QOS_POLICY_ID,
DDS_OWNERSHIPSTRENGTH_QOS_POLICY_ID,
DDS_LIVELINESS_QOS_POLICY_ID,
DDS_TIMEBASEDFILTER_QOS_POLICY_ID,
DDS_PARTITION_QOS_POLICY_ID,
DDS_RELIABILITY_QOS_POLICY_ID,
DDS_DESTINATIONORDER_QOS_POLICY_ID,
DDS_HISTORY_QOS_POLICY_ID,
DDS_RESOURCELIMITS_QOS_POLICY_ID,
DDS_ENTITYFACTORY_QOS_POLICY_ID,
DDS_WRITERDATALIFECYCLE_QOS_POLICY_ID,
DDS_READERDATALIFECYCLE_QOS_POLICY_ID,
DDS_TOPICDATA_QOS_POLICY_ID,
DDS_GROUPDATA_QOS_POLICY_ID,
DDS_TRANSPORTPRIORITY_QOS_POLICY_ID,
DDS_LIFESPAN_QOS_POLICY_ID,
DDS_DURABILITYSERVICE_QOS_POLICY_ID
} dds_qos_policy_id_t;
/* QoS structure is opaque */
/** QoS structure */
typedef struct dds_qos dds_qos_t;
/** Durability QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_durability_kind
{
DDS_DURABILITY_VOLATILE,
DDS_DURABILITY_TRANSIENT_LOCAL,
DDS_DURABILITY_TRANSIENT,
DDS_DURABILITY_PERSISTENT
}
dds_durability_kind_t;
/** History QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_history_kind
{
DDS_HISTORY_KEEP_LAST,
DDS_HISTORY_KEEP_ALL
}
dds_history_kind_t;
/** Ownership QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_ownership_kind
{
DDS_OWNERSHIP_SHARED,
DDS_OWNERSHIP_EXCLUSIVE
}
dds_ownership_kind_t;
/** Liveliness QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_liveliness_kind
{
DDS_LIVELINESS_AUTOMATIC,
DDS_LIVELINESS_MANUAL_BY_PARTICIPANT,
DDS_LIVELINESS_MANUAL_BY_TOPIC
}
dds_liveliness_kind_t;
/** Reliability QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_reliability_kind
{
DDS_RELIABILITY_BEST_EFFORT,
DDS_RELIABILITY_RELIABLE
}
dds_reliability_kind_t;
/** DestinationOrder QoS: Applies to Topic, DataReader, DataWriter */
typedef enum dds_destination_order_kind
{
DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP,
DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP
}
dds_destination_order_kind_t;
/** Presentation QoS: Applies to Publisher, Subscriber */
typedef enum dds_presentation_access_scope_kind
{
DDS_PRESENTATION_INSTANCE,
DDS_PRESENTATION_TOPIC,
DDS_PRESENTATION_GROUP
}
dds_presentation_access_scope_kind_t;
/** Ignore-local QoS: Applies to DataReader, DataWriter */
typedef enum dds_ignorelocal_kind
{
DDS_IGNORELOCAL_NONE,
DDS_IGNORELOCAL_PARTICIPANT,
DDS_IGNORELOCAL_PROCESS
}
dds_ignorelocal_kind_t;
#if defined (__cplusplus)
}
#endif
#endif

12
src/core/ddsc/src/dds__qos.h
View file

@ -21,12 +21,12 @@
extern "C" {
#endif
bool validate_deadline_and_timebased_filter (const nn_duration_t deadline, const nn_duration_t minimum_separation);
bool validate_entityfactory_qospolicy (const nn_entity_factory_qospolicy_t * entityfactory);
bool validate_octetseq (const nn_octetseq_t* seq);
bool validate_partition_qospolicy (const nn_partition_qospolicy_t * partition);
bool validate_reliability_qospolicy (const nn_reliability_qospolicy_t * reliability);
bool validate_stringseq (const nn_stringseq_t* seq);
bool validate_deadline_and_timebased_filter (const dds_duration_t deadline, const dds_duration_t minimum_separation);
bool validate_entityfactory_qospolicy (const dds_entity_factory_qospolicy_t * entityfactory);
bool validate_octetseq (const ddsi_octetseq_t* seq);
bool validate_partition_qospolicy (const dds_partition_qospolicy_t * partition);
bool validate_reliability_qospolicy (const dds_reliability_qospolicy_t * reliability);
bool validate_stringseq (const ddsi_stringseq_t* seq);
bool dds_qos_validate_common (const dds_qos_t *qos);
dds_return_t dds_qos_validate_mutable_common (const dds_qos_t *qos);

4
src/core/ddsc/src/dds__rhc.h
View file

@ -19,7 +19,7 @@ extern "C" {
#endif
struct rhc;
struct nn_xqos;
struct dds_qos;
struct ddsi_serdata;
struct ddsi_tkmap_instance;
struct proxy_writer_info;
@ -54,7 +54,7 @@ dds_rhc_take(
dds_instance_handle_t handle,
dds_readcond *cond);
DDS_EXPORT void dds_rhc_set_qos (struct rhc * rhc, const struct nn_xqos * qos);
DDS_EXPORT void dds_rhc_set_qos (struct rhc * rhc, const struct dds_qos * qos);
DDS_EXPORT bool dds_rhc_add_readcondition (dds_readcond * cond);
DDS_EXPORT void dds_rhc_remove_readcondition (dds_readcond * cond);

2
src/core/ddsc/src/dds__serdata_builtintopic.h
View file

@ -24,7 +24,7 @@ struct ddsi_serdata_builtintopic {
struct ddsi_serdata c;
nn_guid_t key;
dds_instance_handle_t pphandle;
nn_xqos_t xqos;
dds_qos_t xqos;
};
enum ddsi_sertopic_builtintopic_type {

2
src/core/ddsc/src/dds_builtin.c
View file

@ -128,7 +128,7 @@ bool dds__validate_builtin_reader_qos (dds_entity_t topic, const dds_qos_t *qos)
assert (0);
return false;
}
return qos_match_p (qos, bwr->wr.xqos) && !qos_has_resource_limits (qos);
return !qos_match_p (qos, bwr->wr.xqos, NULL) && !qos_has_resource_limits (qos);
}
}

139
src/core/ddsc/src/dds_qos.c
View file

@ -14,12 +14,7 @@
#include "dds__qos.h"
#include "dds/ddsi/q_config.h"
/* TODO: dd_duration_t is converted to nn_ddsi_time_t declared in q_time.h
This structure contain seconds and fractions.
Revisit on the conversion as default values are { 0x7fffffff, 0xffffffff }
*/
static void dds_qos_data_copy_in (nn_octetseq_t *data, const void * __restrict value, size_t sz)
static void dds_qos_data_copy_in (ddsi_octetseq_t *data, const void * __restrict value, size_t sz)
{
if (data->value)
{
@ -34,7 +29,7 @@ static void dds_qos_data_copy_in (nn_octetseq_t *data, const void * __restrict v
}
}
static bool dds_qos_data_copy_out (const nn_octetseq_t *data, void **value, size_t *sz)
static bool dds_qos_data_copy_out (const ddsi_octetseq_t *data, void **value, size_t *sz)
{
assert (data->length < UINT32_MAX);
if (sz == NULL && value != NULL)
@ -57,13 +52,13 @@ static bool dds_qos_data_copy_out (const nn_octetseq_t *data, void **value, size
return true;
}
bool validate_octetseq (const nn_octetseq_t *seq)
bool validate_octetseq (const ddsi_octetseq_t *seq)
{
/* default value is NULL with length 0 */
return ((seq->length == 0 && seq->value == NULL) || (seq->length > 0 && seq->length < UINT32_MAX));
}
bool validate_stringseq (const nn_stringseq_t *seq)
bool validate_stringseq (const ddsi_stringseq_t *seq)
{
if (seq->n == 0)
return (seq->strs == NULL);
@ -76,30 +71,30 @@ bool validate_stringseq (const nn_stringseq_t *seq)
}
}
bool validate_entityfactory_qospolicy (const nn_entity_factory_qospolicy_t *entityfactory)
bool validate_entityfactory_qospolicy (const dds_entity_factory_qospolicy_t *entityfactory)
{
/* Bools must be 0 or 1, i.e., only the lsb may be set */
return !(entityfactory->autoenable_created_entities & ~1);
}
bool validate_reliability_qospolicy (const nn_reliability_qospolicy_t *reliability)
bool validate_reliability_qospolicy (const dds_reliability_qospolicy_t *reliability)
{
return ((reliability->kind == NN_BEST_EFFORT_RELIABILITY_QOS || reliability->kind == NN_RELIABLE_RELIABILITY_QOS) &&
(validate_duration (&reliability->max_blocking_time) == 0));
return ((reliability->kind == DDS_RELIABILITY_BEST_EFFORT || reliability->kind == DDS_RELIABILITY_RELIABLE) &&
(validate_duration (reliability->max_blocking_time) == 0));
}
bool validate_deadline_and_timebased_filter (const nn_duration_t deadline, const nn_duration_t minimum_separation)
bool validate_deadline_and_timebased_filter (const dds_duration_t deadline, const dds_duration_t minimum_separation)
{
return (validate_duration (&deadline) == DDS_RETCODE_OK &&
validate_duration (&minimum_separation) == DDS_RETCODE_OK &&
nn_from_ddsi_duration (minimum_separation) <= nn_from_ddsi_duration (deadline));
return (validate_duration (deadline) == DDS_RETCODE_OK &&
validate_duration (minimum_separation) == DDS_RETCODE_OK &&
minimum_separation <= deadline);
}
bool dds_qos_validate_common (const dds_qos_t *qos)
{
return !(((qos->present & QP_DURABILITY) && validate_durability_qospolicy (&qos->durability) != DDS_RETCODE_OK) ||
((qos->present & QP_DEADLINE) && validate_duration (&qos->deadline.deadline) != DDS_RETCODE_OK) ||
((qos->present & QP_LATENCY_BUDGET) && validate_duration (&qos->latency_budget.duration) != DDS_RETCODE_OK) ||
((qos->present & QP_DEADLINE) && validate_duration (qos->deadline.deadline) != DDS_RETCODE_OK) ||
((qos->present & QP_LATENCY_BUDGET) && validate_duration (qos->latency_budget.duration) != DDS_RETCODE_OK) ||
((qos->present & QP_OWNERSHIP) && validate_ownership_qospolicy (&qos->ownership) != DDS_RETCODE_OK) ||
((qos->present & QP_LIVELINESS) && validate_liveliness_qospolicy (&qos->liveliness) != DDS_RETCODE_OK) ||
((qos->present & QP_RELIABILITY) && ! validate_reliability_qospolicy (&qos->reliability)) ||
@ -134,32 +129,32 @@ static void dds_qos_init_defaults (dds_qos_t * __restrict qos)
{
assert (qos);
memset (qos, 0, sizeof (*qos));
qos->durability.kind = (nn_durability_kind_t) DDS_DURABILITY_VOLATILE;
qos->deadline.deadline = nn_to_ddsi_duration (DDS_INFINITY);
qos->durability_service.service_cleanup_delay = nn_to_ddsi_duration (0);
qos->durability_service.history.kind = (nn_history_kind_t) DDS_HISTORY_KEEP_LAST;
qos->durability.kind = DDS_DURABILITY_VOLATILE;
qos->deadline.deadline = DDS_INFINITY;
qos->durability_service.service_cleanup_delay = 0;
qos->durability_service.history.kind = DDS_HISTORY_KEEP_LAST;
qos->durability_service.history.depth = 1;
qos->durability_service.resource_limits.max_samples = DDS_LENGTH_UNLIMITED;
qos->durability_service.resource_limits.max_instances = DDS_LENGTH_UNLIMITED;
qos->durability_service.resource_limits.max_samples_per_instance = DDS_LENGTH_UNLIMITED;
qos->presentation.access_scope = (nn_presentation_access_scope_kind_t) DDS_PRESENTATION_INSTANCE;
qos->latency_budget.duration = nn_to_ddsi_duration (0);
qos->ownership.kind = (nn_ownership_kind_t) DDS_OWNERSHIP_SHARED;
qos->liveliness.kind = (nn_liveliness_kind_t) DDS_LIVELINESS_AUTOMATIC;
qos->liveliness.lease_duration = nn_to_ddsi_duration (DDS_INFINITY);
qos->time_based_filter.minimum_separation = nn_to_ddsi_duration (0);
qos->reliability.kind = (nn_reliability_kind_t) DDS_RELIABILITY_BEST_EFFORT;
qos->reliability.max_blocking_time = nn_to_ddsi_duration (DDS_MSECS (100));
qos->lifespan.duration = nn_to_ddsi_duration (DDS_INFINITY);
qos->destination_order.kind = (nn_destination_order_kind_t) DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP;
qos->history.kind = (nn_history_kind_t) DDS_HISTORY_KEEP_LAST;
qos->presentation.access_scope = DDS_PRESENTATION_INSTANCE;
qos->latency_budget.duration = 0;
qos->ownership.kind = DDS_OWNERSHIP_SHARED;
qos->liveliness.kind = DDS_LIVELINESS_AUTOMATIC;
qos->liveliness.lease_duration = DDS_INFINITY;
qos->time_based_filter.minimum_separation = 0;
qos->reliability.kind = DDS_RELIABILITY_BEST_EFFORT;
qos->reliability.max_blocking_time = DDS_MSECS (100);
qos->lifespan.duration = DDS_INFINITY;
qos->destination_order.kind = DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP;
qos->history.kind = DDS_HISTORY_KEEP_LAST;
qos->history.depth = 1;
qos->resource_limits.max_samples = DDS_LENGTH_UNLIMITED;
qos->resource_limits.max_instances = DDS_LENGTH_UNLIMITED;
qos->resource_limits.max_samples_per_instance = DDS_LENGTH_UNLIMITED;
qos->writer_data_lifecycle.autodispose_unregistered_instances = true;
qos->reader_data_lifecycle.autopurge_nowriter_samples_delay = nn_to_ddsi_duration (DDS_INFINITY);
qos->reader_data_lifecycle.autopurge_disposed_samples_delay = nn_to_ddsi_duration (DDS_INFINITY);
qos->reader_data_lifecycle.autopurge_nowriter_samples_delay = DDS_INFINITY;
qos->reader_data_lifecycle.autopurge_disposed_samples_delay = DDS_INFINITY;
}
dds_qos_t *dds_create_qos (void)
@ -269,7 +264,7 @@ void dds_qset_durability (dds_qos_t * __restrict qos, dds_durability_kind_t kind
{
if (qos != NULL)
{
qos->durability.kind = (nn_durability_kind_t) kind;
qos->durability.kind = kind;
qos->present |= QP_DURABILITY;
}
}
@ -278,7 +273,7 @@ void dds_qset_history (dds_qos_t * __restrict qos, dds_history_kind_t kind, int3
{
if (qos != NULL)
{
qos->history.kind = (nn_history_kind_t) kind;
qos->history.kind = kind;
qos->history.depth = depth;
qos->present |= QP_HISTORY;
}
@ -299,7 +294,7 @@ void dds_qset_presentation (dds_qos_t * __restrict qos, dds_presentation_access_
{
if (qos != NULL)
{
qos->presentation.access_scope = (nn_presentation_access_scope_kind_t) access_scope;
qos->presentation.access_scope = access_scope;
qos->presentation.coherent_access = coherent_access;
qos->presentation.ordered_access = ordered_access;
qos->present |= QP_PRESENTATION;
@ -310,7 +305,7 @@ void dds_qset_lifespan (dds_qos_t * __restrict qos, dds_duration_t lifespan)
{
if (qos != NULL)
{
qos->lifespan.duration = nn_to_ddsi_duration (lifespan);
qos->lifespan.duration = lifespan;
qos->present |= QP_LIFESPAN;
}
}
@ -319,7 +314,7 @@ void dds_qset_deadline (dds_qos_t * __restrict qos, dds_duration_t deadline)
{
if (qos != NULL)
{
qos->deadline.deadline = nn_to_ddsi_duration (deadline);
qos->deadline.deadline = deadline;
qos->present |= QP_DEADLINE;
}
}
@ -328,7 +323,7 @@ void dds_qset_latency_budget (dds_qos_t * __restrict qos, dds_duration_t duratio
{
if (qos != NULL)
{
qos->latency_budget.duration = nn_to_ddsi_duration (duration);
qos->latency_budget.duration = duration;
qos->present |= QP_LATENCY_BUDGET;
}
}
@ -337,7 +332,7 @@ void dds_qset_ownership (dds_qos_t * __restrict qos, dds_ownership_kind_t kind)
{
if (qos != NULL)
{
qos->ownership.kind = (nn_ownership_kind_t) kind;
qos->ownership.kind = kind;
qos->present |= QP_OWNERSHIP;
}
}
@ -355,8 +350,8 @@ void dds_qset_liveliness (dds_qos_t * __restrict qos, dds_liveliness_kind_t kind
{
if (qos != NULL)
{
qos->liveliness.kind = (nn_liveliness_kind_t) kind;
qos->liveliness.lease_duration = nn_to_ddsi_duration (lease_duration);
qos->liveliness.kind = kind;
qos->liveliness.lease_duration = lease_duration;
qos->present |= QP_LIVELINESS;
}
}
@ -365,7 +360,7 @@ void dds_qset_time_based_filter (dds_qos_t * __restrict qos, dds_duration_t mini
{
if (qos != NULL)
{
qos->time_based_filter.minimum_separation = nn_to_ddsi_duration (minimum_separation);
qos->time_based_filter.minimum_separation = minimum_separation;
qos->present |= QP_TIME_BASED_FILTER;
}
}
@ -405,8 +400,8 @@ void dds_qset_reliability (dds_qos_t * __restrict qos, dds_reliability_kind_t ki
{
if (qos != NULL)
{
qos->reliability.kind = (nn_reliability_kind_t) kind;
qos->reliability.max_blocking_time = nn_to_ddsi_duration (max_blocking_time);
qos->reliability.kind = kind;
qos->reliability.max_blocking_time = max_blocking_time;
qos->present |= QP_RELIABILITY;
}
}
@ -424,7 +419,7 @@ void dds_qset_destination_order (dds_qos_t * __restrict qos, dds_destination_ord
{
if (qos != NULL)
{
qos->destination_order.kind = (nn_destination_order_kind_t) kind;
qos->destination_order.kind = kind;
qos->present |= QP_DESTINATION_ORDER;
}
}
@ -442,8 +437,8 @@ void dds_qset_reader_data_lifecycle (dds_qos_t * __restrict qos, dds_duration_t
{
if (qos != NULL)
{
qos->reader_data_lifecycle.autopurge_nowriter_samples_delay = nn_to_ddsi_duration (autopurge_nowriter_samples_delay);
qos->reader_data_lifecycle.autopurge_disposed_samples_delay = nn_to_ddsi_duration (autopurge_disposed_samples_delay);
qos->reader_data_lifecycle.autopurge_nowriter_samples_delay = autopurge_nowriter_samples_delay;
qos->reader_data_lifecycle.autopurge_disposed_samples_delay = autopurge_disposed_samples_delay;
qos->present |= QP_PRISMTECH_READER_DATA_LIFECYCLE;
}
}
@ -452,8 +447,8 @@ void dds_qset_durability_service (dds_qos_t * __restrict qos, dds_duration_t ser
{
if (qos != NULL)
{
qos->durability_service.service_cleanup_delay = nn_to_ddsi_duration (service_cleanup_delay);
qos->durability_service.history.kind = (nn_history_kind_t) history_kind;
qos->durability_service.service_cleanup_delay = service_cleanup_delay;
qos->durability_service.history.kind = history_kind;
qos->durability_service.history.depth = history_depth;
qos->durability_service.resource_limits.max_samples = max_samples;
qos->durability_service.resource_limits.max_instances = max_instances;
@ -466,7 +461,7 @@ void dds_qset_ignorelocal (dds_qos_t * __restrict qos, dds_ignorelocal_kind_t ig
{
if (qos != NULL)
{
qos->ignorelocal.value = (nn_ignorelocal_kind_t) ignore;
qos->ignorelocal.value = ignore;
qos->present |= QP_CYCLONE_IGNORELOCAL;
}
}
@ -497,7 +492,7 @@ bool dds_qget_durability (const dds_qos_t * __restrict qos, dds_durability_kind_
if (qos == NULL || !(qos->present & QP_DURABILITY))
return false;
if (kind)
*kind = (dds_durability_kind_t) qos->durability.kind;
*kind = qos->durability.kind;
return true;
}
@ -506,7 +501,7 @@ bool dds_qget_history (const dds_qos_t * __restrict qos, dds_history_kind_t *kin
if (qos == NULL || !(qos->present & QP_HISTORY))
return false;
if (kind)
*kind = (dds_history_kind_t) qos->history.kind;
*kind = qos->history.kind;
if (depth)
*depth = qos->history.depth;
return true;
@ -530,7 +525,7 @@ bool dds_qget_presentation (const dds_qos_t * __restrict qos, dds_presentation_a
if (qos == NULL || !(qos->present & QP_PRESENTATION))
return false;
if (access_scope)
*access_scope = (dds_presentation_access_scope_kind_t) qos->presentation.access_scope;
*access_scope = qos->presentation.access_scope;
if (coherent_access)
*coherent_access = qos->presentation.coherent_access;
if (ordered_access)
@ -543,7 +538,7 @@ bool dds_qget_lifespan (const dds_qos_t * __restrict qos, dds_duration_t *lifesp
if (qos == NULL || !(qos->present & QP_LIFESPAN))
return false;
if (lifespan)
*lifespan = nn_from_ddsi_duration (qos->lifespan.duration);
*lifespan = qos->lifespan.duration;
return true;
}
@ -552,7 +547,7 @@ bool dds_qget_deadline (const dds_qos_t * __restrict qos, dds_duration_t *deadli
if (qos == NULL || !(qos->present & QP_DEADLINE))
return false;
if (deadline)
*deadline = nn_from_ddsi_duration (qos->deadline.deadline);
*deadline = qos->deadline.deadline;
return true;
}
@ -561,7 +556,7 @@ bool dds_qget_latency_budget (const dds_qos_t * __restrict qos, dds_duration_t *
if (qos == NULL || !(qos->present & QP_LATENCY_BUDGET))
return false;
if (duration)
*duration = nn_from_ddsi_duration (qos->latency_budget.duration);
*duration = qos->latency_budget.duration;
return true;
}
@ -570,7 +565,7 @@ bool dds_qget_ownership (const dds_qos_t * __restrict qos, dds_ownership_kind_t
if (qos == NULL || !(qos->present & QP_OWNERSHIP))
return false;
if (kind)
*kind = (dds_ownership_kind_t) qos->ownership.kind;
*kind = qos->ownership.kind;
return true;
}
@ -588,9 +583,9 @@ bool dds_qget_liveliness (const dds_qos_t * __restrict qos, dds_liveliness_kind_
if (qos == NULL || !(qos->present & QP_LIVELINESS))
return false;
if (kind)
*kind = (dds_liveliness_kind_t) qos->liveliness.kind;
*kind = qos->liveliness.kind;
if (lease_duration)
*lease_duration = nn_from_ddsi_duration (qos->liveliness.lease_duration);
*lease_duration = qos->liveliness.lease_duration;
return true;
}
@ -599,7 +594,7 @@ bool dds_qget_time_based_filter (const dds_qos_t * __restrict qos, dds_duration_
if (qos == NULL || !(qos->present & QP_TIME_BASED_FILTER))
return false;
if (minimum_separation)
*minimum_separation = nn_from_ddsi_duration (qos->time_based_filter.minimum_separation);
*minimum_separation = qos->time_based_filter.minimum_separation;
return true;
}
@ -630,9 +625,9 @@ bool dds_qget_reliability (const dds_qos_t * __restrict qos, dds_reliability_kin
if (qos == NULL || !(qos->present & QP_RELIABILITY))
return false;
if (kind)
*kind = (dds_reliability_kind_t) qos->reliability.kind;
*kind = qos->reliability.kind;
if (max_blocking_time)
*max_blocking_time = nn_from_ddsi_duration (qos->reliability.max_blocking_time);
*max_blocking_time = qos->reliability.max_blocking_time;
return true;
}
@ -650,7 +645,7 @@ bool dds_qget_destination_order (const dds_qos_t * __restrict qos, dds_destinati
if (qos == NULL || !(qos->present & QP_DESTINATION_ORDER))
return false;
if (kind)
*kind = (dds_destination_order_kind_t) qos->destination_order.kind;
*kind = qos->destination_order.kind;
return true;
}
@ -668,9 +663,9 @@ bool dds_qget_reader_data_lifecycle (const dds_qos_t * __restrict qos, dds_durat
if (qos == NULL || !(qos->present & QP_PRISMTECH_READER_DATA_LIFECYCLE))
return false;
if (autopurge_nowriter_samples_delay)
*autopurge_nowriter_samples_delay = nn_from_ddsi_duration (qos->reader_data_lifecycle.autopurge_nowriter_samples_delay);
*autopurge_nowriter_samples_delay = qos->reader_data_lifecycle.autopurge_nowriter_samples_delay;
if (autopurge_disposed_samples_delay)
*autopurge_disposed_samples_delay = nn_from_ddsi_duration (qos->reader_data_lifecycle.autopurge_disposed_samples_delay);
*autopurge_disposed_samples_delay = qos->reader_data_lifecycle.autopurge_disposed_samples_delay;
return true;
}
@ -679,9 +674,9 @@ bool dds_qget_durability_service (const dds_qos_t * __restrict qos, dds_duration
if (qos == NULL || !(qos->present & QP_DURABILITY_SERVICE))
return false;
if (service_cleanup_delay)
*service_cleanup_delay = nn_from_ddsi_duration (qos->durability_service.service_cleanup_delay);
*service_cleanup_delay = qos->durability_service.service_cleanup_delay;
if (history_kind)
*history_kind = (dds_history_kind_t) qos->durability_service.history.kind;
*history_kind = qos->durability_service.history.kind;
if (history_depth)
*history_depth = qos->durability_service.history.depth;
if (max_samples)
@ -698,6 +693,6 @@ bool dds_qget_ignorelocal (const dds_qos_t * __restrict qos, dds_ignorelocal_kin
if (qos == NULL || !(qos->present & QP_CYCLONE_IGNORELOCAL))
return false;
if (ignore)
*ignore = (dds_ignorelocal_kind_t) qos->ignorelocal.value;
*ignore = qos->ignorelocal.value;
return true;
}

4
src/core/ddsc/src/dds_reader.c
View file

@ -87,7 +87,7 @@ static dds_return_t dds_reader_qos_validate (const dds_qos_t *qos, bool enabled)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_PRISMTECH_READER_DATA_LIFECYCLE) && validate_reader_data_lifecycle (&qos->reader_data_lifecycle) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_TIME_BASED_FILTER) && validate_duration (&qos->time_based_filter.minimum_separation) < 0)
if ((qos->present & QP_TIME_BASED_FILTER) && validate_duration (qos->time_based_filter.minimum_separation) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && validate_history_and_resource_limits (&qos->history, &qos->resource_limits) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
@ -432,7 +432,7 @@ dds_entity_t dds_create_reader (dds_entity_t participant_or_subscriber, dds_enti
thread_state_asleep (lookup_thread_state ());
/* For persistent data register reader with durability */
if (dds_global.m_dur_reader && (rd->m_entity.m_qos->durability.kind > NN_TRANSIENT_LOCAL_DURABILITY_QOS)) {
if (dds_global.m_dur_reader && (rd->m_entity.m_qos->durability.kind > DDS_DURABILITY_TRANSIENT_LOCAL)) {
(dds_global.m_dur_reader) (rd, rhc);
}
dds_topic_unlock (tp);

12
src/core/ddsc/src/dds_rhc.c
View file

@ -464,18 +464,18 @@ struct rhc * dds_rhc_new (dds_reader * reader, const struct ddsi_sertopic * topi
return rhc;
}
void dds_rhc_set_qos (struct rhc * rhc, const nn_xqos_t * qos)
void dds_rhc_set_qos (struct rhc * rhc, const dds_qos_t * qos)
{
/* Set read related QoS */
rhc->max_samples = qos->resource_limits.max_samples;
rhc->max_instances = qos->resource_limits.max_instances;
rhc->max_samples_per_instance = qos->resource_limits.max_samples_per_instance;
rhc->by_source_ordering = (qos->destination_order.kind == NN_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS);
rhc->exclusive_ownership = (qos->ownership.kind == NN_EXCLUSIVE_OWNERSHIP_QOS);
rhc->reliable = (qos->reliability.kind == NN_RELIABLE_RELIABILITY_QOS);
assert(qos->history.kind != NN_KEEP_LAST_HISTORY_QOS || qos->history.depth > 0);
rhc->history_depth = (qos->history.kind == NN_KEEP_LAST_HISTORY_QOS) ? (uint32_t)qos->history.depth : ~0u;
rhc->by_source_ordering = (qos->destination_order.kind == DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP);
rhc->exclusive_ownership = (qos->ownership.kind == DDS_OWNERSHIP_EXCLUSIVE);
rhc->reliable = (qos->reliability.kind == DDS_RELIABILITY_RELIABLE);
assert(qos->history.kind != DDS_HISTORY_KEEP_LAST || qos->history.depth > 0);
rhc->history_depth = (qos->history.kind == DDS_HISTORY_KEEP_LAST) ? (uint32_t)qos->history.depth : ~0u;
}
static bool eval_predicate_sample (const struct rhc *rhc, const struct ddsi_serdata *sample, bool (*pred) (const void *sample))

2
src/core/ddsc/src/dds_serdata_builtintopic.c
View file

@ -186,7 +186,7 @@ static char *dds_string_dup_reuse (char *old, const char *src)
return memcpy (new, src, size);
}
static dds_qos_t *dds_qos_from_xqos_reuse (dds_qos_t *old, const nn_xqos_t *src)
static dds_qos_t *dds_qos_from_xqos_reuse (dds_qos_t *old, const dds_qos_t *src)
{
if (old == NULL)
{

2
src/core/ddsc/src/dds_topic.c
View file

@ -188,7 +188,7 @@ static dds_return_t dds_topic_qos_validate (const dds_qos_t *qos, bool enabled)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_DURABILITY_SERVICE) && validate_durability_service_qospolicy(&qos->durability_service) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_LIFESPAN) && validate_duration(&qos->lifespan.duration) < 0)
if ((qos->present & QP_LIFESPAN) && validate_duration(qos->lifespan.duration) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && validate_history_and_resource_limits(&qos->history, &qos->resource_limits) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;

4
src/core/ddsc/src/dds_write.c
View file

@ -96,7 +96,7 @@ static dds_return_t deliver_locally (struct writer *wr, struct ddsi_serdata *pay
struct reader ** const rdary = wr->rdary.rdary;
if (rdary[0])
{
dds_duration_t max_block_ms = nn_from_ddsi_duration (wr->xqos->reliability.max_blocking_time);
dds_duration_t max_block_ms = wr->xqos->reliability.max_blocking_time;
struct proxy_writer_info pwr_info;
unsigned i;
make_proxy_writer_info (&pwr_info, &wr->e, wr->xqos);
@ -121,7 +121,7 @@ static dds_return_t deliver_locally (struct writer *wr, struct ddsi_serdata *pay
ddsrt_avl_iter_t it;
struct pwr_rd_match *m;
struct proxy_writer_info pwr_info;
dds_duration_t max_block_ms = nn_from_ddsi_duration (wr->xqos->reliability.max_blocking_time);
dds_duration_t max_block_ms = wr->xqos->reliability.max_blocking_time;
ddsrt_mutex_unlock (&wr->rdary.rdary_lock);
make_proxy_writer_info (&pwr_info, &wr->e, wr->xqos);
ddsrt_mutex_lock (&wr->e.lock);

10
src/core/ddsc/src/dds_writer.c
View file

@ -162,7 +162,7 @@ static void dds_writer_status_cb (void *ventity, const status_cb_data_t *data)
ddsrt_mutex_unlock (&entity->m_observers_lock);
}
static uint32_t get_bandwidth_limit (nn_transport_priority_qospolicy_t transport_priority)
static uint32_t get_bandwidth_limit (dds_transport_priority_qospolicy_t transport_priority)
{
#ifdef DDSI_INCLUDE_NETWORK_CHANNELS
struct config_channel_listelem *channel = find_channel (transport_priority);
@ -214,7 +214,7 @@ static dds_return_t dds_writer_qos_validate (const dds_qos_t *qos, bool enabled)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_DURABILITY_SERVICE) && validate_durability_service_qospolicy (&qos->durability_service) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_LIFESPAN) && validate_duration (&qos->lifespan.duration) < 0)
if ((qos->present & QP_LIFESPAN) && validate_duration (qos->lifespan.duration) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
if ((qos->present & QP_HISTORY) && (qos->present & QP_RESOURCE_LIMITS) && validate_history_and_resource_limits(&qos->history, &qos->resource_limits) < 0)
return DDS_RETCODE_INCONSISTENT_POLICY;
@ -264,8 +264,8 @@ static struct whc *make_whc (const dds_qos_t *qos)
/* Construct WHC -- if aggressive_keep_last1 is set, the WHC will
drop all samples for which a later update is available. This
forces it to maintain a tlidx. */
handle_as_transient_local = (qos->durability.kind == NN_TRANSIENT_LOCAL_DURABILITY_QOS);
if (qos->history.kind == NN_KEEP_ALL_HISTORY_QOS)
handle_as_transient_local = (qos->durability.kind == DDS_DURABILITY_TRANSIENT_LOCAL);
if (qos->history.kind == DDS_HISTORY_KEEP_ALL)
hdepth = 0;
else
hdepth = (unsigned) qos->history.depth;
@ -273,7 +273,7 @@ static struct whc *make_whc (const dds_qos_t *qos)
tldepth = 0;
else
{
if (qos->durability_service.history.kind == NN_KEEP_ALL_HISTORY_QOS)
if (qos->durability_service.history.kind == DDS_HISTORY_KEEP_ALL)
tldepth = 0;
else
tldepth = (unsigned) qos->durability_service.history.depth;

9
src/core/ddsc/tests/entity_status.c
View file

@ -41,7 +41,14 @@ static dds_time_t waitTimeout = DDS_SECS (2);
static dds_time_t shortTimeout = DDS_MSECS (10);
static dds_publication_matched_status_t publication_matched;
static dds_subscription_matched_status_t subscription_matched;
static dds_resource_limits_qospolicy_t resource_limits = {1,1,1};
struct reslimits {
int32_t max_samples;
int32_t max_instances;
int32_t max_samples_per_instance;
};
static struct reslimits resource_limits = {1,1,1};
static dds_instance_handle_t reader_i_hdl = 0;
static dds_instance_handle_t writer_i_hdl = 0;