CycloneDDS QoS Mapping

Detailed QoS policy mapping between HDDS and CycloneDDS.

Reliability

HDDS

// Best Effort
let qos = DataWriterQos::default()
    .reliability(Reliability::BestEffort);

// Reliable
let qos = DataWriterQos::default()
    .reliability(Reliability::Reliable {
        max_blocking_time: Duration::from_millis(100),
    });

CycloneDDS (C API)

// Best Effort
dds_qset_reliability(qos, DDS_RELIABILITY_BEST_EFFORT, 0);

// Reliable
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100));

CycloneDDS (XML)

<Reliability>
    <Kind>reliable</Kind>
    <MaxBlockingTime>100ms</MaxBlockingTime>
</Reliability>

Durability

HDDS

DataWriterQos::default()
    .durability(Durability::TransientLocal)

CycloneDDS (C API)

dds_qset_durability(qos, DDS_DURABILITY_TRANSIENT_LOCAL);

CycloneDDS (XML)

<Durability><Kind>transient_local</Kind></Durability>

Mapping Table

HDDS	CycloneDDS C	CycloneDDS XML
Volatile	DDS_DURABILITY_VOLATILE	volatile
TransientLocal	DDS_DURABILITY_TRANSIENT_LOCAL	transient_local
Transient	DDS_DURABILITY_TRANSIENT	transient
Persistent	DDS_DURABILITY_PERSISTENT	persistent

History

HDDS

// Keep Last
DataWriterQos::default()
    .history(History::KeepLast { depth: 10 })

// Keep All
DataWriterQos::default()
    .history(History::KeepAll)

CycloneDDS (C API)

// Keep Last
dds_qset_history(qos, DDS_HISTORY_KEEP_LAST, 10);

// Keep All
dds_qset_history(qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED);

CycloneDDS (XML)

<History>
    <Kind>keep_last</Kind>
    <Depth>10</Depth>
</History>

Deadline

HDDS

DataWriterQos::default()
    .deadline(Duration::from_millis(100))

CycloneDDS (C API)

dds_qset_deadline(qos, DDS_MSECS(100));

CycloneDDS (XML)

<Deadline>100ms</Deadline>

Liveliness

HDDS

DataWriterQos::default()
    .liveliness(Liveliness::ManualByTopic {
        lease_duration: Duration::from_secs(1),
    })

CycloneDDS (C API)

dds_qset_liveliness(qos, DDS_LIVELINESS_MANUAL_BY_TOPIC, DDS_SECS(1));

CycloneDDS (XML)

<Liveliness>
    <Kind>manual_by_topic</Kind>
    <LeaseDuration>1s</LeaseDuration>
</Liveliness>

Mapping Table

HDDS	CycloneDDS C	CycloneDDS XML
Automatic	DDS_LIVELINESS_AUTOMATIC	automatic
ManualByParticipant	DDS_LIVELINESS_MANUAL_BY_PARTICIPANT	manual_by_participant
ManualByTopic	DDS_LIVELINESS_MANUAL_BY_TOPIC	manual_by_topic

Ownership

HDDS

DataWriterQos::default()
    .ownership(Ownership::Exclusive)
    .ownership_strength(100)

CycloneDDS (C API)

dds_qset_ownership(qos, DDS_OWNERSHIP_EXCLUSIVE);
dds_qset_ownership_strength(qos, 100);

CycloneDDS (XML)

<Ownership><Kind>exclusive</Kind></Ownership>
<OwnershipStrength><Value>100</Value></OwnershipStrength>

Resource Limits

HDDS

DataReaderQos::default()
    .resource_limits(ResourceLimits {
        max_samples: 1000,
        max_instances: 100,
        max_samples_per_instance: 10,
    })

CycloneDDS (C API)

dds_qset_resource_limits(qos, 1000, 100, 10);

CycloneDDS (XML)

<ResourceLimits>
    <MaxSamples>1000</MaxSamples>
    <MaxInstances>100</MaxInstances>
    <MaxSamplesPerInstance>10</MaxSamplesPerInstance>
</ResourceLimits>

Partition

HDDS

PublisherQos::default()
    .partition(Partition::new(vec!["sensors", "telemetry"]))

CycloneDDS (C API)

const char *partitions[] = {"sensors", "telemetry"};
dds_qset_partition(qos, 2, partitions);

CycloneDDS (XML)

<Partition>
    <Name>sensors</Name>
    <Name>telemetry</Name>
</Partition>

Time-Based Filter

HDDS

DataReaderQos::default()
    .time_based_filter(Duration::from_millis(100))

CycloneDDS (C API)

dds_qset_time_based_filter(qos, DDS_MSECS(100));

CycloneDDS (XML)

<TimeBasedFilter>
    <MinimumSeparation>100ms</MinimumSeparation>
</TimeBasedFilter>

Complete QoS Example

HDDS Writer QoS

let writer_qos = DataWriterQos::default()
    .reliability(Reliability::Reliable {
        max_blocking_time: Duration::from_millis(100),
    })
    .durability(Durability::TransientLocal)
    .history(History::KeepLast { depth: 10 })
    .deadline(Duration::from_millis(200))
    .liveliness(Liveliness::Automatic {
        lease_duration: Duration::from_secs(5),
    });

CycloneDDS Writer QoS (C)

dds_qos_t *qos = dds_create_qos();
dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100));
dds_qset_durability(qos, DDS_DURABILITY_TRANSIENT_LOCAL);
dds_qset_history(qos, DDS_HISTORY_KEEP_LAST, 10);
dds_qset_deadline(qos, DDS_MSECS(200));
dds_qset_liveliness(qos, DDS_LIVELINESS_AUTOMATIC, DDS_SECS(5));

dds_entity_t writer = dds_create_writer(participant, topic, qos, NULL);
dds_delete_qos(qos);

CycloneDDS Writer QoS (XML)

<DataWriter name="SensorWriter">
    <Reliability>
        <Kind>reliable</Kind>
        <MaxBlockingTime>100ms</MaxBlockingTime>
    </Reliability>
    <Durability><Kind>transient_local</Kind></Durability>
    <History><Kind>keep_last</Kind><Depth>10</Depth></History>
    <Deadline>200ms</Deadline>
    <Liveliness>
        <Kind>automatic</Kind>
        <LeaseDuration>5s</LeaseDuration>
    </Liveliness>
</DataWriter>

Compatibility Notes

1. Default differences: Both default to BestEffort, Volatile, KeepLast(1)
2. Duration format: HDDS uses Rust Duration, CycloneDDS uses nanoseconds or string format
3. XTypes: CycloneDDS has partial XTypes support; use @appendable for safety

Next Steps

• Setup - Installation and configuration
• Example - Complete interop example
• QoS Translation Matrix - All vendors