Struct Qos 

pub struct Qos {

    pub user_data: Option<Vec<u8>>,
    pub topic_data: Option<Vec<u8>>,
    pub group_data: Option<Vec<u8>>,
    pub durability: Option<Durability>,
    pub durability_service: Option<DurabilityService>,
    pub presentation: Option<Presentation>,
    pub deadline: Option<Deadline>,
    pub latency_budget: Option<LatencyBudget>,
    pub ownership: Option<Ownership>,
    pub ownership_strength: Option<OwnershipStrength>,
    pub liveliness: Option<Liveliness>,
    pub time_based_filter: Option<TimeBasedFilter>,
    pub partition: Option<Vec<String>>,
    pub reliability: Option<Reliability>,
    pub transport_priority: Option<TransportPriority>,
    pub lifespan: Option<Lifespan>,
    pub destination_order: Option<DestinationOrder>,
    pub history: Option<History>,
    pub resource_limits: Option<ResourceLimits>,
    pub writer_data_lifecycle: Option<WriterDataLifecycle>,
    pub reader_data_lifecycle: Option<ReaderDataLifecycle>,
    pub writer_batching: Option<WriterBatching>,
    pub type_consistency: Option<TypeConsistency>,
    pub entity_name: Option<EntityName>,
    pub properties: Option<HashMap<String, String>>,
    pub ignore_local: Option<IgnoreLocal>,
    pub data_representation: Option<Vec<dds_data_representation_id_t>>,
}

Fields

user_data: Option<Vec<u8>>

topic_data: Option<Vec<u8>>

group_data: Option<Vec<u8>>

durability: Option<Durability>

durability_service: Option<DurabilityService>

presentation: Option<Presentation>

deadline: Option<Deadline>

latency_budget: Option<LatencyBudget>

ownership: Option<Ownership>

ownership_strength: Option<OwnershipStrength>

liveliness: Option<Liveliness>

time_based_filter: Option<TimeBasedFilter>

partition: Option<Vec<String>>

reliability: Option<Reliability>

transport_priority: Option<TransportPriority>

lifespan: Option<Lifespan>

destination_order: Option<DestinationOrder>

history: Option<History>

resource_limits: Option<ResourceLimits>

writer_data_lifecycle: Option<WriterDataLifecycle>

reader_data_lifecycle: Option<ReaderDataLifecycle>

writer_batching: Option<WriterBatching>

type_consistency: Option<TypeConsistency>

entity_name: Option<EntityName>

properties: Option<HashMap<String, String>>

ignore_local: Option<IgnoreLocal>

data_representation: Option<Vec<dds_data_representation_id_t>>

Implementations

impl Qos

pub unsafe fn from_qos_native(qos: *mut dds_qos_t) -> Self

pub unsafe fn to_qos_native(&self) -> *mut dds_qos_t

pub unsafe fn delete_qos_native(qos: *mut dds_qos_t)

Trait Implementations

impl Clone for Qos

fn clone(&self) -> Qos

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Qos

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Qos

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Qos

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Qos

fn eq(&self, other: &Qos) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Qos

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Qos

impl StructuralPartialEq for Qos