Index

Package: DDS

Description

package DDS is

Packages

Short_Seq (new DDS_Support.Sequences_Generic)

package Short_Seq is new DDS_Support.Sequences_Generic
     (Short,
      Short_Ptr,
      DDS.Natural,
      1,
      Short_Array);

Summary: Instantiates FooSeq < DDS.Short >

Instantiates:
<<generic>> FooSeq
See also: DDS.Short
See also: FooSeq

Long_Seq (new DDS_Support.Sequences_Generic)

package Long_Seq is new DDS_Support.Sequences_Generic
     (Long,
      Long_Ptr,
      DDS.Natural,
      1,
      Long_Array);

Summary: Instantiates FooSeq < DDS.Long >

Instantiates:
<<generic>> FooSeq
See also: DDS.Long
See also: FooSeq

Long_Long_Seq (new DDS_Support.Sequences_Generic)

package Long_Long_Seq is new DDS_Support.Sequences_Generic
     (Long_Long,
      Long_Long_Ptr,
      DDS.Natural,
      1,
      Long_Long_Array);

Summary: Instantiates FooSeq < DDS.LongLong >

Instantiates:
<<generic>> FooSeq
See also: DDS.LongLong
See also: FooSeq

Unsigned_Short_Seq (new DDS_Support.Sequences_Generic)

package Unsigned_Short_Seq is new DDS_Support.Sequences_Generic
     (Unsigned_Short,
      Unsigned_Short_Ptr,
      DDS.Natural,
      1,
      Unsigned_Short_Array);

Summary: Instantiates FooSeq < DDS.UnsignedShort >

Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedShort
See also: FooSeq

Unsigned_Long_Seq (new DDS_Support.Sequences_Generic)

package Unsigned_Long_Seq is new DDS_Support.Sequences_Generic
     (Unsigned_Long,
      Unsigned_Long_Ptr,
      DDS.Natural,
      1,
      Unsigned_Long_Array);

Summary: Instantiates FooSeq < DDS.UnsignedLong >

Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedLong
See also: FooSeq

Unsigned_Long_Long_Seq (new DDS_Support.Sequences_Generic)

package Unsigned_Long_Long_Seq is new DDS_Support.Sequences_Generic
     (Unsigned_Long_Long,
      Unsigned_Long_Long_Ptr,
      DDS.Natural,
      1,
      Unsigned_Long_Long_Array);

Summary: Instantiates FooSeq < DDS.UnsignedLongLong >

Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedLongLong
See also: FooSeq

Enum_Seq (new DDS_Support.Sequences_Generic)

package Enum_Seq is new DDS_Support.Sequences_Generic
     (Enum,
      Enum_Ptr,
      DDS.Natural,
      1,
      Enum_Array);

Float_Seq (new DDS_Support.Sequences_Generic)

package Float_Seq is new DDS_Support.Sequences_Generic
     (Float,
      Float_Ptr,
      DDS.Natural,
      1,
      Float_Array);

Summary: Instantiates FooSeq < DDS.Float >

Instantiates:
<<generic>> FooSeq
See also: DDS.Float
See also: FooSeq

Double_Seq (new DDS_Support.Sequences_Generic)

package Double_Seq is new DDS_Support.Sequences_Generic
     (Double,
      Double_Ptr,
      DDS.Natural,
      1,
      Double_Array);

Summary: Instantiates FooSeq < DDS.Double >

Instantiates:
<<generic>> FooSeq
See also: DDS.Double
See also: FooSeq

Long_Double_Seq (new DDS_Support.Sequences_Generic)

package Long_Double_Seq is new DDS_Support.Sequences_Generic
     (Long_Double,
      Long_Double_Ptr,
      DDS.Natural,
      1,
      Long_Double_Array);

Summary: Instantiates FooSeq < DDS.LongDouble >

Instantiates:
<<generic>> FooSeq
See also: DDS.LongDouble
See also: FooSeq

Char_Seq (new DDS_Support.Sequences_Generic)

package Char_Seq is new DDS_Support.Sequences_Generic
     (Char,
      Char_Ptr,
      DDS.Natural,
      1,
      Char_Array);

Summary: Instantiates FooSeq < DDS.Char >

Instantiates:
<<generic>> FooSeq
See also: DDS.Char
See also: FooSeq

Wchar_Seq (new DDS_Support.Sequences_Generic)

package Wchar_Seq is new DDS_Support.Sequences_Generic
     (Wchar,
      Wchar_Ptr,
      DDS.Natural,
      1,
      Wchar_Array);

Summary: Instantiates FooSeq < DDS.Wchar >

Instantiates:
<<generic>> FooSeq
See also: DDS.Wchar
See also: FooSeq

Octet_Seq (new DDS_Support.Sequences_Generic)

package Octet_Seq is new DDS_Support.Sequences_Generic
     (Octet,
      Octet_Ptr,
      DDS.Natural,
      1,
      Octet_Array);

Summary: Instantiates FooSeq < DDS.Octet >

Instantiates:
<<generic>> FooSeq
See also: DDS.Octet
See also: FooSeq

Octets_Seq (new DDS_Support.Sequences_Generic)

package Octets_Seq is new DDS_Support.Sequences_Generic
     (Octets,
      Octets_Ptr,
      DDS.Natural,
      1,
      Octets_Array);

Summary: Instantiates FooSeq < DDS_Octets > .

Instantiates:
<<generic>> FooSeq
See also: DDS_Octets

Boolean_Seq (new DDS_Support.Sequences_Generic)

package Boolean_Seq is new DDS_Support.Sequences_Generic
     (Boolean,
      Boolean_Ptr,
      DDS.Natural,
      1,
      Boolean_Array);

Summary: Instantiates FooSeq < DDS.Boolean >

Instantiates:
<<generic>> FooSeq
See also: DDS.Boolean
See also: FooSeq

String_Seq (new DDS_Support)

package String_Seq is new DDS_Support.Sequences_Generic
     (DDS.String,
      String_Ptr,
      DDS.Natural,
      1,
      String_Array);

Summary: Instantiates FooSeq < char* > with value type semantics.

StringSeq is a sequence that contains strings.

Instantiates:
<<generic>> FooSeq
See also: FooSeq

KeyedString_Seq (new DDS_Support.Sequences_Generic)

package KeyedString_Seq is new DDS_Support.Sequences_Generic
     (DDS.KeyedString,
      KeyedString_Ptr,
      DDS.Natural,
      1,
      KeyedString_Array);

Summary: Instantiates FooSeq < DDS_KeyedString > .

Instantiates:
<<generic>> FooSeq
See also: DDS_KeyedString

KeyedOctets_Seq (new DDS_Support.Sequences_Generic)

package KeyedOctets_Seq is new DDS_Support.Sequences_Generic
     (DDS.KeyedOctets,
      KeyedOctets_Ptr,
      DDS.Natural,
      1,
      KeyedOctets_Array);

Summary: Instantiates FooSeq < DDS_KeyedOctets >.

Instantiates:
<<generic>> FooSeq
See also: DDS_KeyedOctets

Wide_String_Seq (new DDS_Support.Sequences_Generic)

package Wide_String_Seq is new DDS_Support.Sequences_Generic
     (DDS.Wide_String,
      Wide_String_Ptr,
      DDS.Natural,
      1,
      Wide_String_Array);

Summary: Instantiates FooSeq < DDS.Wchar* >

Instantiates:
<<generic>> FooSeq
See also: DDS.Wchar
See also: DDS.StringSeq
See also: FooSeq

InstanceHandle_Seq (new DDS_Support.Sequences_Generic)

package InstanceHandle_Seq is new DDS_Support.Sequences_Generic
     (InstanceHandle_T,
      InstanceHandle_T_Access,
      DDS.Natural,
      1,
      InstanceHandle_T_Array);

Summary: Instantiates FooSeq < DDS.InstanceHandle_t > .

When reading into this sequence (as with DDS.DataWriter.get_matched_subscriptions or DDS.DataReader.get_matched_publications), the contents of any existing handles in this sequence will be overwritten to avoid the expense of allocating new handles. Therefore, it is generally not a good idea to add handles to a sequence that you obtained elsewhere (e.g. from a Status object or as a result of calling FooDataWriter.register_instance). Any null elements will be replaced by new handles. To avoid allocating new handles on the fly, use the procedure DDS_InstanceHandleSeq.fill.

Instantiates:
<<generic>> FooSeq
See also: DDS.InstanceHandle_t
See also: FooSeq

QosPolicyCount_Seq (new DDS_Support.Sequences_Generic)

package QosPolicyCount_Seq is new DDS_Support.Sequences_Generic
     (QosPolicyCount,
      QosPolicyCount_Access,
      DDS.Natural,
      1,
      QosPolicyCount_Array);

Summary: Declares IDL sequence < DDS.QosPolicyCount >

Instantiates:
<<generic>> FooSeq


See also: DDS.QosPolicyCount

TransportUnicastSettings_Seq (new DDS_Support.Sequences_Generic)

package TransportUnicastSettings_Seq is new DDS_Support.Sequences_Generic
     (TransportUnicastSettings_T,
      TransportUnicastSettings_T_Access,
      DDS.Natural,
      1,
      TransportUnicastSettings_T_Array);

Summary: Declares IDL sequence< DDS.TransportUnicastSettings_t >

Instantiates:
<<generic>> FooSeq


See also: DDS.TransportUnicastSettings_t

TransportMulticastSettings_Seq (new DDS_Support.Sequences_Generic)

package TransportMulticastSettings_Seq is new DDS_Support.Sequences_Generic
     (TransportMulticastSettings_T,
      TransportMulticastSettings_T_Access,
      DDS.Natural,
      1,
      TransportMulticastSettings_T_Array);

Summary: Declares IDL sequence< DDS.TransportMulticastSettings_t >

Instantiates:
<<generic>> FooSeq


See also: DDS.TransportMulticastSettings_t

TransportMulticastMapping_Seq (new DDS_Support.Sequences_Generic)

package TransportMulticastMapping_Seq is new DDS_Support.Sequences_Generic
     (TransportMulticastMapping_T,
      TransportMulticastMapping_T_Access,
      DDS.Natural,
      1,
      TransportMulticastMapping_T_Array);

Summary: Declares IDL sequence< DDS.TransportMulticastMapping_t >

Instantiates:
<<generic>> FooSeq


See also: DDS.TransportMulticastMapping_t

EncapsulationId_Seq (new DDS_Support.Sequences_Generic)

package EncapsulationId_Seq is new DDS_Support.Sequences_Generic
     (EncapsulationId_T,
      EncapsulationId_T_Access,
      DDS.Natural,
      1,
      EncapsulationId_T_Array);

TransportEncapsulationSettings_Seq (new DDS_Support.Sequences_Generic)

package TransportEncapsulationSettings_Seq is new DDS_Support.Sequences_Generic
     (TransportEncapsulationSettings_T,
      TransportEncapsulationSettings_T_Access,
      DDS.Natural,
      1,
      TransportEncapsulationSettings_T_Array);

Discovery_ParticipantInformationSeq (new DDS_Support.Sequences_Generic)

package Discovery_ParticipantInformationSeq is new DDS_Support.Sequences_Generic
     (Discovery_ParticipantInformation,
      Discovery_ParticipantInformation_Access,
      DDS.Natural,
      1,
      Discovery_ParticipantInformation_Array);

Discovery_EndpointInformationSeq (new DDS_Support.Sequences_Generic)

package Discovery_EndpointInformationSeq is new DDS_Support.Sequences_Generic
     (Discovery_EndpointInformation,
      Discovery_EndpointInformation_Access,
      DDS.Natural,
      1,
      Discovery_EndpointInformation_Array);

Locator_Seq (new DDS_Support.Sequences_Generic)

package Locator_Seq is new DDS_Support.Sequences_Generic
     (Locator_T,
      Locator_T_Access,
      DDS.Natural,
      1,
      Locator_T_Array);

Summary: Declares IDL sequence < DDS.Locator_t >


See also: DDS.Locator_t

LocatorFilter_Seq (new DDS_Support.Sequences_Generic)

package LocatorFilter_Seq is new DDS_Support.Sequences_Generic
     (LocatorFilter_T,
      LocatorFilter_T_Access,
      DDS.Natural,
      1,
      LocatorFilter_T_Array);

Summary: Declares IDL sequence< DDS.LocatorFilter_t >.

A sequence of DDS.LocatorFilter_t used to report the channels' properties. If the length of the sequence is zero, the DDS.MultiChannelQosPolicy is not in use.

Instantiates:
<<generic>> FooSeq


See also: DDS.LocatorFilter_t

ChannelSettings_Seq (new DDS_Support.Sequences_Generic)

package ChannelSettings_Seq is new DDS_Support.Sequences_Generic
     (ChannelSettings_T,
      ChannelSettings_T_Access,
      DDS.Natural,
      1,
      ChannelSettings_T_Array);

Summary: Declares IDL sequence< DDS.ChannelSettings_t >

A sequence of DDS.ChannelSettings_t used to configure the channels' properties. If the length of the sequence is zero, the DDS.MultiChannelQosPolicy has no effect.

Instantiates:
<<generic>> FooSeq


See also: DDS.ChannelSettings_t

Property_T_Seq (new DDS_Support.Sequences_Generic)

package Property_T_Seq is new DDS_Support.Sequences_Generic
     (Property_T,
      Property_T_Access,
      DDS.Natural,
      1,
      Property_T_Array);

Summary: Declares IDL sequence < DDS.Property_t >


See also: DDS.Property_t

EndpointGroup_T_Seq (new DDS_Support.Sequences_Generic)

package EndpointGroup_T_Seq is new DDS_Support.Sequences_Generic
     (Element        => EndpointGroup_T,
      Element_Access => EndpointGroup_T_Access,
      Index_Type     => Natural,
      First_Element  => 1,
      Element_Array  => EndpointGroup_T_Array);

Summary: A sequence of DDS.EndpointGroup_t

In the context of Collaborative DataWriters, it can be used by a DDS.DataReader to define a group of remote DataWriters that the DDS.DataReader will wait to discover before skipping missing samples.

In the context of Durable Subscriptions, it can be used to create a set of Durable Subscriptions identified by a name and a quorum count.

Instantiates:
<<generic>> FooSeq
See also: DDS.EndpointGroup_t

Cookie_T_Seq (new DDS_Support.Sequences_Generic)

package Cookie_T_Seq is new DDS_Support.Sequences_Generic
     (Cookie_T,
      Cookie_T_Access,
      DDS.Natural,
      1,
      Cookie_T_Array);

TransportInfo_Seq (new DDS_Support.Sequences_Generic)

package TransportInfo_Seq is new DDS_Support.Sequences_Generic
     (Element        => DDS.TransportInfo_T,
      Element_Access => DDS.TransportInfo_Access,
      Index_Type     => Natural,
      First_Element  => 1,
      Element_Array  => DDS.TransportInfo_Array);

Summary: Instantiates FooSeq < DDS.TransportInfo_t > .

Instantiates:
<<generic>> FooSeq
See also: DDS.TransportInfo_t

ParticipantBuiltinTopicData_Seq (new DDS_Support.Sequences_Generic)

Summary: Instantiates FooSeq < DDS.ParticipantBuiltinTopicData > .

Instantiates:
<<generic>> FooSeq
See also: DDS.ParticipantBuiltinTopicData

TopicBuiltinTopicData_Seq (new DDS_Support.Sequences_Generic)

package TopicBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic
     (Element        => DDS.TopicBuiltinTopicData,
      Element_Access => DDS.TopicBuiltinTopicData_Access,
      Index_Type     => Natural,
      First_Element  => 1,
      Element_Array  => DDS.TopicBuiltinTopicData_Array);

Summary: Instantiates FooSeq < DDS.TopicBuiltinTopicData > .

Instantiates:
<<generic>> FooSeq
See also: DDS.TopicBuiltinTopicData

PublicationBuiltinTopicData_Seq (new DDS_Support.Sequences_Generic)

Summary: Instantiates FooSeq < DDS.PublicationBuiltinTopicData > .

Instantiates:
<<generic>> FooSeq
See also: DDS.PublicationBuiltinTopicData

SubscriptionBuiltinTopicData_Seq (new DDS_Support.Sequences_Generic)

Summary: Instantiates FooSeq < DDS.SubscriptionBuiltinTopicData > .

Instantiates:
<<generic>> FooSeq
See also: DDS.SubscriptionBuiltinTopicData

SampleInfo_Seq (new DDS_Support.Sequences_Generic)

package SampleInfo_Seq is new DDS_Support.Sequences_Generic
     (SampleInfo,
      SampleInfo_Access,
      DDS.Natural,
      1,
      SampleInfo_Array);

Summary: Declares IDL sequence < DDS.SampleInfo > .


See also: FooSeq

Classes

TopicQos

type TopicQos is new Ada.Finalization.Limited_Controlled with record
      Topic_Data         : aliased TopicDataQosPolicy;
      Durability         : aliased DurabilityQosPolicy;
      Durability_Service : aliased DurabilityServiceQosPolicy;
      Deadline           : aliased DeadlineQosPolicy;
      Latency_Budget     : aliased LatencyBudgetQosPolicy;
      Liveliness         : aliased LivelinessQosPolicy;
      Reliability        : aliased ReliabilityQosPolicy;
      Destination_Order  : aliased DestinationOrderQosPolicy;
      History            : aliased HistoryQosPolicy;
      Resource_Limits    : aliased ResourceLimitsQosPolicy;
      Transport_Priority : aliased TransportPriorityQosPolicy;
      Lifespan           : aliased LifespanQosPolicy;
      Ownership          : aliased OwnershipQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Protocol           : aliased TopicProtocolQosPolicy;
   end record with
     Convention => C;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.Topic entity.

You must set certain members in a consistent manner:

length of DDS.TopicQos.topic_data .value <= DDS.DomainParticipantQos.resource_limits .topic_data_max_length

If any of the above are not true, DDS.Topic.set_qos, DDS.Topic.set_qos_with_profile and DDS.DomainParticipant.set_default_topic_qos will fail with DDS.RETCODE_INCONSISTENT_POLICY and DDS.DomainParticipant.create_topic will return NULL.

Entity:
DDS.Topic


See also: DDSQosTypesModule allowed ranges within each Qos.

Topic_Data: Topic data policy, DDSTopicDataQosModule.

Durability: Durability policy, DDSDurabilityQosModule.

Durability_Service: DurabilityService policy, DDSDurabilityServiceQosModule.

Deadline: Deadline policy, DDSDeadlineQosModule.

Latency_Budget: Latency budget policy, DDSLatencyBudgetQosModule.

Liveliness: Liveliness policy, DDSLivelinessQosModule.

Reliability: Reliability policy, DDSReliabilityQosModule.

Destination_Order: Destination order policy, DDSDestinationOrderQosModule.

History: History policy, DDSHistoryQosModule.

Resource_Limits: Resource limits policy, DDSResourceLimitsQosModule.

Transport_Priority: Transport priority policy, DDSTransportPriorityQosModule.

Lifespan: Lifespan policy, DDSLifespanQosModule.

Ownership: Ownership policy, DDSOwnershipQosModule.

DataWriterQos

type DataWriterQos is new Ada.Finalization.Limited_Controlled with record
   ---
      Durability             : aliased DurabilityQosPolicy;
      Durability_Service     : aliased DurabilityServiceQosPolicy;
      Deadline               : aliased DeadlineQosPolicy;
      Latency_Budget         : aliased LatencyBudgetQosPolicy;
      Liveliness             : aliased LivelinessQosPolicy;
      Reliability            : aliased ReliabilityQosPolicy;
      Destination_Order      : aliased DestinationOrderQosPolicy;
      History                : aliased HistoryQosPolicy;
      Resource_Limits        : aliased ResourceLimitsQosPolicy;
      Transport_Priority     : aliased TransportPriorityQosPolicy;
      Lifespan               : aliased LifespanQosPolicy;
      User_Data              : aliased UserDataQosPolicy;
      Ownership              : aliased OwnershipQosPolicy;
      Ownership_Strength     : aliased OwnershipStrengthQosPolicy;
      Writer_Data_Lifecycle  : aliased WriterDataLifecycleQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Writer_Resource_Limits : aliased DataWriterResourceLimitsQosPolicy;
      Protocol               : aliased DataWriterProtocolQosPolicy;
      Transport_Selection    : aliased TransportSelectionQosPolicy;
      Unicast                : aliased TransportUnicastQosPolicy;
      Encapsulation          : aliased TransportEncapsulationQosPolicy;
      Publish_Mode           : aliased PublishModeQosPolicy;
      Property               : aliased PropertyQosPolicy;
      Service                : aliased ServiceQosPolicy;
      Batch                  : aliased BatchQosPolicy;
      Multi_Channel          : aliased MultiChannelQosPolicy;
      Availability           : aliased AvailabilityQosPolicy;
      Publication_Name       : aliased EntityNameQosPolicy;
      Type_Support           : aliased TypeSupportQosPolicy;
      Topic_Query_Dispatch   : aliased TopicQueryDispatchQosPolicy;
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.DataWriter entity.

You must set certain members in a consistent manner:

- DDS.DataWriterQos.history .depth <= DDS.DataWriterQos.resource_limits .max_samples_per_instance

- DDS.DataWriterQos.resource_limits .max_samples_per_instance <= DDS.DataWriterQos.resource_limits .max_samples

- DDS.DataWriterQos.resource_limits .initial_samples <= DDS.DataWriterQos.resource_limits .max_samples

- DDS.DataWriterQos.resource_limits .initial_instances <= DDS.DataWriterQos.resource_limits .max_instances

- length of DDS.DataWriterQos.user_data .value <= DDS.DomainParticipantQos.resource_limits .writer_user_data_max_length

If any of the above are not true, DDS.DataWriter.set_qos and DDS.DataWriter.set_qos_with_profile and DDS.Publisher.set_default_datawriter_qos and DDS.Publisher.set_default_datawriter_qos_with_profile will fail with DDS.RETCODE_INCONSISTENT_POLICY and DDS.Publisher.create_datawriter and DDS.Publisher.create_datawriter_with_profile and will return NULL.

Entity:
DDS.DataWriter


See also: DDSQosTypesModule allowed ranges within each Qos.

Durability: Durability policy, DDSDurabilityQosModule.

Durability_Service: DurabilityService policy, DDSDurabilityServiceQosModule.

Deadline: Deadline policy, DDSDeadlineQosModule.

Latency_Budget: Latency budget policy, DDSLatencyBudgetQosModule.

Liveliness: Liveliness policy, DDSLivelinessQosModule.

Reliability: Reliability policy, DDSReliabilityQosModule.

Destination_Order: Destination order policy, DDSDestinationOrderQosModule.

History: History policy, DDSHistoryQosModule.

Resource_Limits: Resource limits policy, DDSResourceLimitsQosModule.

Transport_Priority: Transport priority policy, DDSTransportPriorityQosModule.

Lifespan: Lifespan policy, DDSLifespanQosModule.

User_Data: User data policy, DDSUserDataQosModule.

Ownership: Ownership policy, DDSOwnershipQosModule.

Ownership_Strength: Ownership strength policy, DDSOwnershipStrengthQosModule.

Writer_Data_Lifecycle: Writer data lifecycle policy, DDSWriterDataLifecycleQosModule.

Writer_Resource_Limits: <<ext>> Writer resource limits policy, DDSDataWriterResourceLimitsQosModule.

Protocol: <<ext>> DDS.DataWriter protocol policy, DDSDataWriterProtocolQosModule

Transport_Selection: <<ext>> Transport plugin selection policy, DDSTransportSelectionQosModule.

Specifies the transports available for use by the DDS.DataWriter.

Unicast: <<ext>> Unicast transport policy, DDSTransportUnicastQosModule.

Specifies the unicast transport interfaces and ports on which messages can be received.

The unicast interfaces are used to receive messages from DDS.DataReader entities in the domain.

Encapsulation: <<ext>> Transport encapsulation policy, DDSTransportEncapsulationQosModule

Specifies data encapsulation formats supported per transport instance of a DDS.DataWriter or DDS.DataReader.

Publish_Mode: <<ext>> Publish mode policy, DDSPublishModeQosModule.

Determines whether the DDS.DataWriter publishes data synchronously or asynchronously and how.

Property: <<ext>> Property policy, DDSPropertyQosModule.

Service: <<ext>> Service policy, DDSServiceQosModule.

batch: <<ext>> Batch policy, DDSBatchQosModule.

multi_channel: <<ext>> Multi channel policy, DDSMultiChannelQosModule.

Availability: <<ext>> Availability policy, DDSAvailabilityQosModule.

publication_name: <<ext>> EntityName policy, DDSEntityNameQosModule.

Type_Support: <<ext>> Type support data, DDSTypeSupportQosModule.

Optional value that is passed to a type plugin's on_endpoint_attached and serialization functions.

Topic_Query_Dispatch: <<ext>> Topic Query dispatch policy, DDSTopicQueryDispatchQosModule.

PublisherQos

type PublisherQos is  new Ada.Finalization.Limited_Controlled with record
      Presentation           : PresentationQosPolicy;
      Partition              : PartitionQosPolicy;
      Group_Data             : GroupDataQosPolicy;
      Entity_Factory         : EntityFactoryQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Asynchronous_Publisher : aliased AsynchronousPublisherQosPolicy;
      Exclusive_Area         : aliased ExclusiveAreaQosPolicy;
      Protocol               : aliased PublisherProtocolQosPolicy;
      Publisher_Name         : aliased EntityNameQosPolicy;
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.Publisher entity.

You must set certain members in a consistent manner:

length of DDS.GroupDataQosPolicy.value <= DDS.DomainParticipantResourceLimitsQosPolicy.publisher_group_data_max_length

length of DDS.PartitionQosPolicy.name <= DDS.DomainParticipantResourceLimitsQosPolicy.max_partitions

combined number of characters (including terminating 0) in DDS.PartitionQosPolicy.name <= DDS.DomainParticipantResourceLimitsQosPolicy.max_partition_cumulative_characters

If any of the above are not true, DDS.Publisher.set_qos and DDS.Publisher.set_qos_with_profile will fail with DDS.RETCODE_INCONSISTENT_POLICY and DDS.DomainParticipant.create_publisher will\ return NULL.

Presentation: Presentation policy, DDSPresentationQosModule.

Partition: Partition policy, DDSPartitionQosModule.

Group_Data: Group data policy, DDSGroupDataQosModule.

Entity_Factory: Entity factory policy, DDSEntityFactoryQosModule.

Asynchronous_Publisher: <<ext>> Asynchronous publishing settings for the DDS.Publisher and all entities that are created by it.

Exclusive_Area: <<ext>> Exclusive area for the DDS.Publisher and all entities that are created by it.

publisher_name: <<ext>> EntityName policy, DDSEntityNameQosModule.

DataReaderQoS

type DataReaderQoS is new Ada.Finalization.Limited_Controlled with record
   ---
      Durability             : aliased DurabilityQosPolicy;
      Deadline               : aliased DeadlineQosPolicy;
      Latency_Budget         : aliased LatencyBudgetQosPolicy;
      Liveliness             : aliased LivelinessQosPolicy;
      Reliability            : aliased ReliabilityQosPolicy;
      Destination_Order      : aliased DestinationOrderQosPolicy;
      History                : aliased HistoryQosPolicy;
      Resource_Limits        : aliased ResourceLimitsQosPolicy;
      User_Data              : aliased UserDataQosPolicy;
      Ownership              : aliased OwnershipQosPolicy;
      Time_Based_Filter      : aliased TimeBasedFilterQosPolicy;
      Reader_Data_Lifecycle  : aliased ReaderDataLifecycleQosPolicy;
      Type_Consistency       : aliased TypeConsistencyEnforcementQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Reader_Resource_Limits : aliased DataReaderResourceLimitsQosPolicy;
      Protocol               : aliased DataReaderProtocolQosPolicy;
      Transport_Selection    : aliased TransportSelectionQosPolicy;
      Unicast                : aliased TransportUnicastQosPolicy;
      Multicast              : aliased TransportMulticastQosPolicy;
      Encapsulation          : aliased TransportEncapsulationQosPolicy;
      Property               : aliased PropertyQosPolicy;
      Service                : aliased ServiceQosPolicy;
      Availability           : aliased AvailabilityQosPolicy;
      Subscription_Name      : aliased EntityNameQosPolicy;
      Transport_Priority     : aliased TransportPriorityQosPolicy;
      Type_Support           : aliased TypeSupportQosPolicy;
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.DataReader entity.

You must set certain members in a consistent manner:

DDS.DataReaderQos.deadline .period >= DDS.DataReaderQos.time_based_filter .minimum_separation

DDS.DataReaderQos.history .depth <= DDS.DataReaderQos.resource_limits .max_samples_per_instance

DDS.DataReaderQos.resource_limits .max_samples_per_instance <= DDS.DataReaderQos.resource_limits .max_samples DDS.DataReaderQos.resource_limits .initial_samples <= DDS.DataReaderQos.resource_limits .max_samples

DDS.DataReaderQos.resource_limits .initial_instances <= DDS.DataReaderQos.resource_limits .max_instances

DDS.DataReaderQos.reader_resource_limits .initial_remote_writers_per_instance <= DDS.DataReaderQos.reader_resource_limits .max_remote_writers_per_instance

DDS.DataReaderQos.reader_resource_limits .initial_infos <= DDS.DataReaderQos.reader_resource_limits .max_infos

DDS.DataReaderQos.reader_resource_limits .max_remote_writers_per_instance <= DDS.DataReaderQos.reader_resource_limits .max_remote_writers

DDS.DataReaderQos.reader_resource_limits .max_samples_per_remote_writer <= DDS.DataReaderQos.resource_limits .max_samples

length of DDS.DataReaderQos.user_data .value <= DDS.DomainParticipantQos.resource_limits .reader_user_data_max_length

If any of the above are not true, DDS.DataReader.set_qos and DDS.DataReader.set_qos_with_profile \endif will fail with DDS.RETCODE_INCONSISTENT_POLICY and \ifnot CPP2_LANGUAGE_ONLY DDS.Subscriber.create_datareader will return NULL.

Durability: Durability policy, DDSDurabilityQosModule.

Deadline: Deadline policy, DDSDeadlineQosModule.

Latency_Budget: Latency budget policy, DDSLatencyBudgetQosModule.

Liveliness: Liveliness policy, DDSLivelinessQosModule.

Reliability: Reliability policy, DDSReliabilityQosModule.

Destination_Order: Destination order policy, DDSDestinationOrderQosModule.

History: History policy, DDSHistoryQosModule.

Resource_Limits: Resource limits policy, DDSResourceLimitsQosModule.

User_Data: User data policy, DDSUserDataQosModule.

Ownership: Ownership policy, DDSOwnershipQosModule.

Time_Based_Filter: Time-based filter policy, DDSTimeBasedFilterQosModule

Reader_Data_Lifecycle: Reader data lifecycle policy, DDSReaderDataLifecycleQosModule

Type_Consistency: Type consistency enforcement policy, DDSTypeConsistencyEnforcementQosModule

Reader_Resource_Limits: <<ext>> DDS.DataReader resource limits policy, DDSDataReaderResourceLimitsQosModule. This policy is an extension to the DDS standard.

Protocol: <<ext>> DDS.DataReader protocol policy, DDSDataReaderProtocolQosModule

Transport_Selection: <<ext>> Transport selection policy, DDSTransportSelectionQosModule.

Specifies the transports available for use by the DDS.DataReader.

Unicast: <<ext>> Unicast transport policy, DDSTransportUnicastQosModule.

Specifies the unicast transport interfaces and ports on which messages can be received.

The unicast interfaces are used to receive messages from DDS.DataWriter entities in the domain.

Multicast: <<ext>> Multicast transport policy, DDSTransportMulticastQosModule.

Specifies the multicast group addresses and ports on which messages can be received.

The multicast addresses are used to receive messages from DDS.DataWriter entities in the domain.

Property: <<ext>> Property policy, DDSPropertyQosModule.

Service: <<ext>> Service policy, DDSServiceQosModule.

Availability: <<ext>> Availability policy, DDSAvailabilityQosModule.

Subscription_Name: <<ext>> EntityName policy, DDSEntityNameQosModule.

Transport_Priority: Transport priority policy, DDSTransportPriorityQosModule.

Type_Support: <<ext>> type support data, DDSTypeSupportQosModule.

Optional value that is passed to a type plugin's on_endpoint_attached and deserialization functions.

SubscriberQos

type SubscriberQos is new Ada.Finalization.Limited_Controlled with record
      Presentation    : PresentationQosPolicy;
      Partition       : PartitionQosPolicy;
      Group_Data      : GroupDataQosPolicy;
      Entity_Factory  : EntityFactoryQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Exclusive_Area  : ExclusiveAreaQosPolicy;
      Protocol        : aliased SubscriberProtocolQosPolicy;
      Subscriber_Name : aliased EntityNameQosPolicy;
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.Subscriber entity.

You must set certain members in a consistent manner:

length of DDS.GroupDataQosPolicy.value <= DDS.DomainParticipantResourceLimitsQosPolicy.subscriber_group_data_max_length

length of DDS.PartitionQosPolicy.name <= DDS.DomainParticipantResourceLimitsQosPolicy.max_partitions

combined number of characters (including terminating 0) in DDS.PartitionQosPolicy.name <= DDS.DomainParticipantResourceLimitsQosPolicy.max_partition_cumulative_characters

If any of the above are not true, DDS.Subscriber.set_qos and DDS.Subscriber.set_qos_with_profile will fail with DDS.RETCODE_INCONSISTENT_POLICY

Presentation: Presentation policy, DDSPresentationQosModule.

Partition: Partition policy, DDSPartitionQosModule.

Group_Data: Group data policy, DDSGroupDataQosModule.

Entity_Factory: Entity factory policy, DDSEntityFactoryQosModule.

Enclusive_Area: <<ext>> Exclusive area for the subscriber and all entities that are created by the subscriber.

subscriber_name: <<ext>> EntityName policy, DDSEntityNameQosModule.

DomainParticipantQos

type DomainParticipantQos is new Ada.Finalization.Limited_Controlled with  record
      User_Data         : aliased UserDataQosPolicy;
      Entity_Factory    : aliased EntityFactoryQosPolicy;
      -- --------------- Extensions: ----------------------------------
      Wire_Protocol     : aliased WireProtocolQosPolicy;
      Transport_Builtin : aliased TransportBuiltinQosPolicy;
      Default_Unicast   : aliased TransportUnicastQosPolicy;
      Discovery         : aliased DiscoveryQosPolicy;
      Resource_Limits   : aliased DomainParticipantResourceLimitsQosPolicy;
      Event             : aliased EventQosPolicy;
      Receiver_Pool     : aliased ReceiverPoolQosPolicy;
      Database          : aliased DatabaseQosPolicy;
      Discovery_Config  : aliased DiscoveryConfigQosPolicy;
      Exclusive_Area    : aliased ExclusiveAreaQosPolicy;
      Property          : aliased PropertyQosPolicy;
      Participant_Name  : aliased EntityNameQosPolicy;
      Multicast_Mapping : aliased TransportMulticastMappingQosPolicy;
      Service           : aliased ServiceQosPolicy;
      User_Object       : aliased UserObjectQosPolicy;
      Protocol          : aliased DomainParticipantProtocolQosPolicy;
      Type_Support      : aliased TypeSupportQosPolicy;
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.DomainParticipant entity.

Certain members must be set in a consistent manner:

Length of DDS.DomainParticipantQos.user_data .value <= DDS.DomainParticipantQos.resource_limits .participant_user_data_max_length

For DDS.DomainParticipantQos.discovery_config .publication_writer
high_watermark <= DDS.DomainParticipantQos.resource_limits .local_writer_allocation .max_count heartbeats_per_max_samples <= DDS.DomainParticipantQos.resource_limits .local_writer_allocation.max_count

For DDS.DomainParticipantQos.discovery_config .suscription_writer
high_watermark <= DDS.DomainParticipantQos.resource_limits .local_reader_allocation.max_count heartbeats_per_max_samples <= DDS.DomainParticipantQos.resource_limits .local_reader_allocation.max_count

If any of the above are not true, DDS.DomainParticipant.set_qos and DDS.DomainParticipant.set_qos_with_profile and DDS.DomainParticipantFactory.set_default_participant_qos will fail with DDS.RETCODE_INCONSISTENT_POLICY, and DDS.DomainParticipantFactory.create_participant will fail.

Entity:
DDS.DomainParticipant


See also: DDSQosTypesModule and allowed ranges within each Qos.


See also: NDDS_DISCOVERY_PEERS

User_Data: User data policy, DDSUserDataQosModule.

Entity_Factory: Entity factory policy, DDSEntityFactoryQosModule.

Wire_Protocol: <<ext>> Wire Protocol policy, DDSWireProtocolQosModule.

The wire protocol (RTPS) attributes associated with the participant.

Transport_Builtin: <<ext>> Transport Builtin policy, DDSTransportBuiltinQosModule.

Default_Unicast: <<ext>> Default Unicast Transport policy, DDSTransportUnicastQosModule.

Discovery: <<ext>> Discovery policy, DDSDiscoveryQosModule.

Resource_Limits: <<ext>> Domain participant resource limits policy, DDSDomainParticipantResourceLimitsQosModule.

Event: <<ext>> Event policy, DDSEventQosModule.

Receiver_Pool: <<ext>> Receiver pool policy, DDSReceiverPoolQosModule.

Database: <<ext>> Database policy, DDSDatabaseQosModule.

Discovery_Config: <<ext>> Discovery config policy, DDSDiscoveryConfigQosModule.

Exclusive_Area: <<ext>> Exclusive area for the domain and all entities that are created by the domain.

Property: <<ext>> Property policy, DDSPropertyQosModule.

Participant_Name: <<ext>> The participant name. DDSEntityNameQosModule

Multicast_Mapping: <<ext>> The multicast mapping policy. DDSTransportMulticastMappingQosModule

User_Object: <<ext>> Size and alignment of user object stored in each entity. DDSUserObjectModule.

Type_Support: <<ext>> Type support data, DDSTypeSupportQosModule.

Optional value that is passed to a type plugin's on_participant_attached function.

TODO: Add Docs for Service

DomainParticipantFactoryQos

type DomainParticipantFactoryQos is new Ada.Finalization.Limited_Controlled with  record
      Entity_Factory  : aliased EntityFactoryQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Resource_Limits : aliased SystemResourceLimitsQosPolicy;
      Profile         : aliased ProfileQosPolicy;
      Logging         : aliased DDS_LoggingQosPolicy := (0,
                                                         NDDS_CONFIG_LOG_CATEGORY_PLATFORM,
                                                         0,
                                                         Interfaces.C.Strings.Null_Ptr,
                                                         Interfaces.C.Strings.Null_Ptr,
                                                         Interfaces.C.int (-1),
                                                         Interfaces.C.int (-1));
   end record;

Primitive operations:

GetInterface

Summary: QoS policies supported by a DDS.DomainParticipantFactory.

Entity:
DDS.DomainParticipantFactory


See also: DDSQosTypesModule and allowed ranges within each Qos.

Entity_Factory: Entity factory policy, DDSEntityFactoryQosModule.

Resource_Limits: <<ext>> System resource limits, DDSSystemResourceLimitsQosModule.

Note: This QoS policy cannot be configured from XML configuration files.

Profile: <<ext>> Qos profile policy, DDSProfileQosModule.

Note: This QoS policy cannot be configured from XML configuration files.

Logging: <<ext>> Logging qos policy, DDSLoggingQosModule.

Types

Short

type    Short              is new Interfaces.C.short;

Summary: Defines a short integer data type, equivalent to IDL/CDR short.

A 16-bit signed short integer value.

Long

type    Long               is new Interfaces.C.int;

Summary: Defines a long integer data type, equivalent to IDL/CDR long.

A 32-bit signed long integer value.

Integer

subtype Integer  is Long;

Natural

subtype Natural  is Integer range 0 .. Integer'Last;

Positive

subtype Positive is Integer range 1 .. Integer'Last;

Long_Long

type Long_Long          is new Interfaces.Integer_64;

Summary: Defines an extra-long integer data type, equivalent to IDL/CDR long long.

A 64-bit signed long long integer value.

Unsigned_Short

type Unsigned_Short     is new Interfaces.Unsigned_16;

Summary: Defines an unsigned short integer data type, equivalent to IDL/CDR unsigned short.

A 16-bit unsigned short integer value.

Unsigned_Long

type Unsigned_Long      is new Interfaces.Unsigned_32;

Summary: Defines an unsigned long integer data type, equivalent to IDL/CDR unsigned long.

A 32-bit unsigned long integer value.

Unsigned_Long_Long

type Unsigned_Long_Long is new Interfaces.Unsigned_64;

Summary: Defines an unsigned extra-long data type, equivalent to IDL/CDR unsigned long long.

An 64-bit unsigned long long integer value.

Enum

type Enum               is new Interfaces.Unsigned_32;

Summary: Defines an enumerated data type.

Encoded as unsigned long value. By default, the first enum identifier has the numeric value zero (0). Successive enum identifiers take ascending numeric values, in order of declaration from left to right.

Float

type Float           is new Interfaces.IEEE_Float_32;

Summary: Defines a single-precision floating-point data type, equivalent to IDL/CDR float.

A 32-bit floating-point value.

Double

type Double          is new Interfaces.IEEE_Float_64;

Summary: Defines a double-precision floating-point data type, equivalent to IDL/CDR double.

A 64-bit floating-point value.

Long_Double

type Long_Double     is new Interfaces.IEEE_Extended_Float;

Summary: Defines an extra-precision floating-point data type, equivalent to IDL/CDR long double.

A 128-bit floating-point value.

Char

subtype Char            is Standard.Character;

Summary: Defines a character data type, equivalent to IDL/CDR char.

An 8-bit quantity that encodes a single byte charater from any byte-oriented code set.

Wchar

subtype Wchar           is Standard.Wide_Wide_Character;

Summary: Defines a wide character data type, equivalent to IDL/CDR wchar.

An 32-bit quantity that encodes a wide character from any character set.

Octet

subtype Octet           is Interfaces.Unsigned_8;

Summary: Defines an opaque byte data type, equivalent to IDL/CDR octet.

An 8-bit quantity that is guaranteed not to undergo any conversion when transmitted by the middleware.

Octets

type Octets is record
      Length : Integer;
      Value  : System.Address;
   end record with
     Convention => C;

Summary: Built-in type consisting of a variable-length array of opaque bytes.

length: Number of octets to serialize.

value: DDS_Octets array value.

Boolean

subtype Boolean         is Standard.Boolean;

Summary: Defines a Boolean data type, equivalent to IDL/CDR boolean.

An 8-bit Boolean value that is used to denote a data item that can only take one of the values DDS.BOOLEAN_TRUE (1) or DDS.BOOLEAN_FALSE (0).

String

type String  is limited record
      Data  : aliased Interfaces.C.Strings.chars_ptr := Interfaces.C.Strings.Null_Ptr;
      pragma Obsolescent (Data, "This is internal data and not to be referenced outside the DDS hierachy:" &
                            "use Operations on the whole record instead!");
   end record with
     Convention => C;

Summary: A string of single-byte characters, equivalent to IDL/CDR string.

Has a range of ISO Latin-1 (except ASCII NULL) and a variable length.

KeyedString

type KeyedString is record
      Key   : DDS.String;
      Value : DDS.String;
   end record with
     Convention => C;

Summary: Keyed string built-in type.

key: Instance key associated with the specified value.

value: String value.

KeyedOctets

type KeyedOctets is record
      Key    : DDS.String;
      Value  : Octets;
   end record with
     Convention => C;

Summary: Built-in type consisting of a variable-length array of opaque bytes and a string that is the key.

key: Instance key associated with the specified value.

length: Number of octets to serialize.

value: DDS_Octets array value.

Wwchars_Ptr

type Wwchars_Ptr is access all Standard.Wide_Wide_Character;

Wide_String

type Wide_String is limited record
      Data : Wwchars_Ptr;
   end record with
     Convention => C;

Short_Ptr

type    Short_Ptr              is access all Short;

Long_Ptr

type    Long_Ptr               is access all Long;

Long_Long_Ptr

type    Long_Long_Ptr          is access all Long_Long;

Unsigned_Short_Ptr

type    Unsigned_Short_Ptr     is access all Unsigned_Short;

Unsigned_Long_Ptr

type    Unsigned_Long_Ptr      is access all Unsigned_Long;

Unsigned_Long_Long_Ptr

type    Unsigned_Long_Long_Ptr is access all Unsigned_Long_Long;

Enum_Ptr

type    Enum_Ptr               is access all Enum;

Float_Ptr

type    Float_Ptr              is access all Float;

Double_Ptr

type    Double_Ptr             is access all Double;

Long_Double_Ptr

type    Long_Double_Ptr        is access all Long_Double;

Char_Ptr

type    Char_Ptr               is access all Char;

Wchar_Ptr

type    Wchar_Ptr              is access all Wchar;

Octet_Ptr

type    Octet_Ptr              is access all Octet;

Octets_Ptr

type    Octets_Ptr             is access all Octets;

Boolean_Ptr

type    Boolean_Ptr            is access all Boolean;

String_Ptr

type    String_Ptr             is access all String;

KeyedString_Ptr

type    KeyedString_Ptr        is access all KeyedString;

KeyedOctets_Ptr

type    KeyedOctets_Ptr        is access all KeyedOctets;

Wide_String_Ptr

type    Wide_String_Ptr        is access all Wide_String;

DomainId_T

type DomainId_T is new Long range 0 .. DOMAIN_ID_MAX
     with Default_Value => 0;

Summary: An integer that indicates in which domain a DDS.DomainParticipant communicates.

Participants with the same DDS.DomainId_t are said to be in the same domain, and can thus communicate with one another.

The lower limit for a domain ID is 0. The upper limit for a domain ID is determined by the guidelines stated in DDS.RtpsWellKnownPorts_t (specifically DDS.RtpsWellKnownPorts_t.domain_id_gain)

Short_Array

type Short_Array is array (Natural range <>) of aliased Short;

Long_Array

type Long_Array is array (Natural range <>) of aliased Long;

Long_Long_Array

type Long_Long_Array is array (Natural range <>) of aliased Long_Long;

Unsigned_Short_Array

type Unsigned_Short_Array is array (Natural range <>) of aliased Unsigned_Short;

Unsigned_Long_Array

type Unsigned_Long_Array is array (Natural range <>) of aliased Unsigned_Long;

Unsigned_Long_Long_Array

type Unsigned_Long_Long_Array is array (Natural range <>) of aliased Unsigned_Long_Long;

Enum_Array

type Enum_Array is array (Natural range <>) of aliased Enum;

Float_Array

type Float_Array is array (Natural range <>) of aliased Float;

Double_Array

type Double_Array is array (Natural range <>) of aliased Double;

Long_Double_Array

type Long_Double_Array is array (Natural range <>) of aliased Long_Double;

Char_Array

type Char_Array is array (Natural range <>) of aliased Char;

Wchar_Array

type Wchar_Array is array (Natural range <>) of aliased Wchar;

Octet_Array

type Octet_Array is array (Natural range <>) of aliased Octet;

Octets_Array

type Octets_Array is array (Natural range <>) of aliased Octets;

Boolean_Array

type Boolean_Array is array (Natural range <>) of aliased Boolean;

String_Array

type String_Array is array (Natural range <>) of aliased DDS.String;

KeyedString_Array

type KeyedString_Array is array (Natural range <>) of aliased DDS.KeyedString;

KeyedOctets_Array

type KeyedOctets_Array is array (Natural range <>) of aliased DDS.KeyedOctets;

Wide_String_Array

type Wide_String_Array is array (Natural range <>) of aliased DDS.Wide_String;

Time_T

type Time_T is record
      Sec     : Long := 0;
      Nanosec : Unsigned_Long := 0;
   end record with
     Convention => C;

Summary: Type for time representation.

A DDS.Time_t represents a moment in time.

Sec: seconds

Nanosec: nanoseconds

Duration_T

type Duration_T is record -- Default DURATION_ZERO
      Sec     : Long := 0;
      Nanosec : Unsigned_Long := 0;
   end record with
     Convention => C;

Summary: Type for duration representation.

Represents a time interval.

Sec: seconds

Nanosec: nanoseconds

Builtin_Topic_Key_Type_Native

type Builtin_Topic_Key_Type_Native is new Interfaces.Unsigned_32;

InstanceHandle_T

type InstanceHandle_T is new RTIDDS.Low_Level.dds_c.infrastructure_h.DDS_InstanceHandle_t;

Summary: Type definition for an instance handle.

Handle to identiy different instances of the same DDS.Topic of a certain type.


See also: FooDataWriter.register_instance
See also: DDS.SampleInfo.instance_handle

InstanceHandle_T_Access

type InstanceHandle_T_Access is access all InstanceHandle_T;

InstanceHandle_T_Array

type InstanceHandle_T_Array is array (Natural range <>) of aliased InstanceHandle_T;

GUID_T_Value_Array

subtype GUID_T_Value_Array is  Octet_Array (0 .. 15);
------------------------------------------------- Guid_t -------------------------------------------------

Guid_T

type Guid_T is record
      Value : aliased GUID_T_Value_Array := (others => 0);
   end record with
     Convention => C;

Summary: Type for GUID (Global Unique Identifier) representation.

Represents a 128 bit GUID.

Value: A 16 byte array containing the GUID value

Guid_T_Access

type Guid_T_Access is access all Guid_T;

SequenceNumber_T

type SequenceNumber_T is record
      High : aliased Long := 0;
      Low  : aliased Unsigned_Long := 0;
   end record with
     Convention => C;

Summary: Type for sequence number representation.

Represents a 64-bit sequence number.

High: The most significant part of the sequence number

Low: The least significant part of the sequence number

SequenceNumber_T_Access

type SequenceNumber_T_Access is access all  SequenceNumber_T;

OriginalWriterInfo_T

type OriginalWriterInfo_T is record
      Writer_Guid     : Guid_T;
      Sequence_Number : SequenceNumber_T;
   end record with
     Convention => C;

ReturnCode_T

type ReturnCode_T is
     (RETCODE_OK,
      --  Successful return.
      RETCODE_ERROR,
      --  Generic, unspecified error.

      RETCODE_UNSUPPORTED,
      --  Unsupported operation. Can only returned by operations that are unsupported.
      RETCODE_BAD_PARAMETER,
      RETCODE_PRECONDITION_NOT_MET,
      RETCODE_OUT_OF_RESOURCES,
      RETCODE_NOT_ENABLED,
      RETCODE_IMMUTABLE_POLICY,
      RETCODE_INCONSISTENT_POLICY,
      RETCODE_ALREADY_DELETED,
      RETCODE_TIMEOUT,
      RETCODE_NO_DATA,
      RETCODE_ILLEGAL_OPERATION
     );

StatusKind

type StatusKind is new Unsigned_Long;

Summary: Type for status kinds

Each concrete DDS.Entity is associated with a set of *Status objects whose values represent the communication status of that DDS.Entity.

The communication statuses whose changes can be communicated to the application depend on the DDS.Entity.

Each status value can be accessed with a corresponding procedure on the DDS.Entity. The changes on these status values cause activation of the corresponding DDS.StatusCondition objects and trigger invocation of the proper DDS.Listener objects to asynchronously inform the application. Note that not all statuses will activate the DDS.StatusCondition or have a corresponding listener callback. Refer to the documentation of the individual statuses for that information.


See also: DDS.Entity, DDS.StatusCondition, DDS.Listener

StatusMask

subtype StatusMask is StatusKind;

Summary: A bit-mask (list) of concrete status types, i.e. DDS.StatusKind[].

The bit-mask is an efficient and compact representation of a fixed-length list of DDS.StatusKind values.

Bits in the mask correspond to different statuses. You can choose which changes in status will trigger a callback by setting the corresponding status bits in this bit-mask and installing callbacks for each of those statuses.

The bits that are true indicate that the listener will be called back for changes in the corresponding status.

Bits in the mask correspond to different statuses. You can choose which changes in status will trigger a callback by setting the corresponding status bits in this bit-mask and installing callbacks for each of those statuses.

The bits that are true indicate that the listener will be called back for changes in the corresponding status.

StatusKind_Access

type StatusKind_Access is access constant StatusKind;

ThreadSettings

type ThreadSettings is new Unsigned_Long;

ThreadSettingsKindMask

subtype ThreadSettingsKindMask is ThreadSettings;

Summary: A mask of which each bit is taken from DDS.ThreadSettingsKind.


See also: DDS.ThreadSettings_t

ThreadSettingsCpuRotationKind_T

type ThreadSettingsCpuRotationKind_T is new Unsigned_Long;

Summary: Determines how DDS.ThreadSettings_t.cpu_list affects processor affinity for thread-related QoS policies that apply to multiple threads.

Controlling CPU Core Affinity for RTI Threads

Most thread-related QoS settings apply to a single thread (such as for the DDS.EventQosPolicy, DDS.DatabaseQosPolicy, and DDS.AsynchronousPublisherQosPolicy). However, the thread settings in the DDS.ReceiverPoolQosPolicy control every receive thread created. In this case, there are several schemes to map M threads to N processors; the rotation kind controls which scheme is used.

Controlling CPU Core Affinity is only relevant to the DDS.ReceiverPoolQosPolicy. It is ignored within other QoS policies that include DDS.ThreadSettings_t.

If DDS.ThreadSettings_t.cpu_list is empty, the rotation is irrelevant since no affinity adjustment will occur. Suppose instead that DDS.ThreadSettings_t.cpu_list ={0,1} and that the middleware creates three receive threads: {A, B, C}. If DDS.ThreadSettings_t.cpu_rotation is DDS.THREAD_SETTINGS_CPU_NO_ROTATION, threads A, B and C will have the same processor affinities (0-1), andthe OS will control thread scheduling within this bound. It is common to denote CPU affinities as a bitmask, where set bits represent allowed processors to run on. This mask is printed in hex, so a CPU core affinity of 0-1 can be represented by the mask 0x3.

If DDS.ThreadSettings_t.cpu_rotation is DDS.THREAD_SETTINGS_CPU_RR_ROTATION, each thread will be assigned in round-robin fashion to one of the processors in DDS.ThreadSettings_t.cpu_list; perhaps thread A to 0, B to 1, and C to 0. Note that the order in which internal middleware threads spawn is unspecified.

Not all of these options may be relevant for all operating systems. Refer to the Platform Notes for further information.

ThreadSettings_T

type ThreadSettings_T is record
      Mask         : aliased ThreadSettingsKindMask := THREAD_SETTINGS_OPTION_DEFAULT;
      Priority     : aliased Long := -9999999;
      Stack_Size   : aliased Long := -1;
      Cpu_List     : aliased Long_Seq.Sequence;
      Cpu_Rotation : aliased ThreadSettingsCpuRotationKind_T := THREAD_SETTINGS_CPU_ROTATION_DEFAULT;
   end record with
     Convention => C;

Summary: The properties of a thread of execution.

QoS:
DDS.EventQosPolicy DDS.DatabaseQosPolicy DDS.ReceiverPoolQosPolicy DDS.AsynchronousPublisherQosPolicy

Mask: Describes the type of thread.

The meaning of each bit of the mask are defined by DDS.ThreadSettingsKind.

[default] 0, use default options of the OS

Priority: Thread priority.

Important: The interpretation of numeric thread priority values is different based on whether the priority is specified in your application code or in an XML QoS profile document. This is because QoS profile documents are intended to be usable across programming languages.

[range] java.lang.Thread.MIN_PRIORITY to MAX_PRIORITY if set programmatically in Java code ange Platform-dependent - Consult Platform Notes for additional details. if set in a QoS profile document

Stack_Size: The thread stack-size.

[range] Platform-dependent. Consult Platform Notes for additional details.

Cpu_List: The list of processors on which the thread(s) may run.

A sequence of integers that represent the set of processors on which the thread(s) controlled by this QoS may run. An empty sequence (the default) means the middleware wlll make no CPU affinity adjustments.

Note: This feature is currently only supported on a subset of architectures (see the Platform Notes ). The API may change as more architectures are added in future releases.

This value is only relevant to the DDS.ReceiverPoolQosPolicy. It is ignored within other QoS policies that include DDS.ThreadSettings_t.


See also: ThreadSettingsCpuRotationKind_usage

[default] Empty sequence

Cpu_Rotation: Determines how processor affinity is applied to multiple threads.

This value is only relevant to the DDS.ReceiverPoolQosPolicy. It is ignored within other QoS policies that include DDS.ThreadSettings_t.


See also: ThreadSettingsCpuRotationKind_usage

Note: This feature is currently only supported on a subset of architectures (see the Platform Notes ). The API may change as more architectures are added in future releases.

ThreadSettings_T_Access

type ThreadSettings_T_Access is access all  ThreadSettings_T;

QosPolicyId_T

type QosPolicyId_T is new Unsigned_Long;

Summary: Type to identify QosPolicies.

QosPolicyCount

type QosPolicyCount is record
      Policy_Id : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
      Count     : aliased Long := 0;
   end record with
     Convention => C;

Summary: Type to hold a counter for a DDS.QosPolicyId_t

Policy_Id: The QosPolicy ID

Count: a counter

QosPolicyCount_Access

type QosPolicyCount_Access is access all QosPolicyCount;

QosPolicyCount_Array

type QosPolicyCount_Array is array (Natural range <>) of aliased QosPolicyCount;

EntityKind_T

type EntityKind_T is (UNKNOWN_ENTITY_KIND,
                         PARTICIPANT_ENTITY_KIND,
                         PUBLISHER_ENTITY_KIND,
                         SUBSCRIBER_ENTITY_KIND,
                         TOPIC_ENTITY_KIND,
                         DATAREADER_ENTITY_KIND,
                         DATAWRITER_ENTITY_KIND);

UserDataQosPolicy

type UserDataQosPolicy is limited record
      Value : aliased Octet_Seq.Sequence;
   end record with
     Convention => C;

Summary: Attaches a buffer of opaque data that is distributed by means of DDSBuiltInTopicModule during discovery.

Entity:
DDS.DomainParticipant, DDS.DataReader, DDS.DataWriter

Properties:
"Rx0" = NO;
"Changeable" = "YES"


See also: DDS.DomainParticipant.get_builtin_subscriber

Usage

The purpose of this QoS is to allow the application to attach additional information to the created DDS.Entity objects, so that when a remote application discovers their existence, it can access that information and use it for its own purposes. This information is not used by dds.

One possible use of this QoS is to attach security credentials or some other information that can be used by the remote application to authenticate the source.

In combination with operations such as DDS.DomainParticipant.ignore_participant, DDS.DomainParticipant.ignore_publication, DDS.DomainParticipant.ignore_subscription, and DDS.DomainParticipant.ignore_topic, this QoS policy can assist an application to define and enforce its own security policies.

The use of this QoS is not limited to security; it offers a simple, yet flexible extensibility mechanism.

Important: RTI Connext stores the data placed in this policy in pre-allocated pools. It is therefore necessary to configure RTI Connext with the maximum size of the data that will be stored in policies of this type. This size is configured with DDS.DomainParticipantResourceLimitsQosPolicy.participant_user_data_max_length, DDS.DomainParticipantResourceLimitsQosPolicy.writer_user_data_max_length, and DDS.DomainParticipantResourceLimitsQosPolicy.reader_user_data_max_length.

Value: a sequence of octets

[default] empty (zero-length)

[range] Octet sequence of length [0,max_length]

TopicDataQosPolicy

type TopicDataQosPolicy is limited record
      Value : aliased Octet_Seq.Sequence;
   end record with
     Convention => C;

Summary: Attaches a buffer of opaque data that is distributed by means of DDSBuiltInTopicModule during discovery.

Entity:
DDS.Topic

Properties:
"Rx0" = NO
"Changeable" = "YES"


See also: DDS.DomainParticipant.get_builtin_subscriber

Usage

The purpose of this QoS is to allow the application to attach additional information to the created DDS.Topic objects, so that when a remote application discovers their existence, it can access that information and use it for its own purposes. This extra data is not used by dds.

One possible use of this QoS is to attach security credentials or some other information that can be used by the remote application to authenticate the source.

In combination with DDS.DataReaderListener, DDS.DataWriterListener, or operations such as DDS.DomainParticipant.ignore_topic, this QoS policy can assist an application in defining and enforcing its own security policies.

The use of this QoS is not limited to security; it offers a simple, yet flexible extensibility mechanism.

Important: RTI Connext stores the data placed in this policy in pre-allocated pools. It is therefore necessary to configure RTI Connext with the maximum size of the data that will be stored in policies of this type. This size is configured with DDS.DomainParticipantResourceLimitsQosPolicy.topic_data_max_length.

Value: a sequence of octets

[default] empty (zero-length)

[range] Octet sequence of length [0,max_length]

GroupDataQosPolicy

type GroupDataQosPolicy is limited record
      Value : aliased Octet_Seq.Sequence;
   end record with
     Convention => C;

Summary: Attaches a buffer of opaque data that is distributed by means of DDSBuiltInTopicModule during discovery.

Entity:
DDS.Publisher, DDS.Subscriber

Properties:
"Rx0" = NO
"Changeable" = "YES"


See also: DDS.DomainParticipant.get_builtin_subscriber

Usage

The additional information is attached to a DDS.Publisher or DDS.Subscriber. This extra data is not used by RTI Connext itself. When a remote application discovers the DDS.Publisher or DDS.Subscriber, it can access that information and use it for its own purposes.

Use cases for this QoS policy, as well as the DDS.TopicDataQosPolicy and DDS.UserDataQosPolicy, are often application-to-application identification, authentication, authorization, and encryption purposes. For example, applications can use Group or User Data to send security certificates to each other for RSA-type security.

In combination with DDS.DataReaderListener, DDS.DataWriterListener and operations such as DDS.DomainParticipant.ignore_publication and DDS.DomainParticipant.ignore_subscription, this QoS policy can help an application to define and enforce its own security policies. For example, an application can implement matching policies similar to those of the DDS.PartitionQosPolicy, except the decision can be made based on an application-defined policy.

The use of this QoS is not limited to security; it offers a simple, yet flexible extensibility mechanism.

Important: RTI Connext stores the data placed in this policy in pre-allocated pools. It is therefore necessary to configure RTI Connext with the maximum size of the data that will be stored in policies of this type. This size is configured with DDS.DomainParticipantResourceLimitsQosPolicy.publisher_group_data_max_length and DDS.DomainParticipantResourceLimitsQosPolicy.subscriber_group_data_max_length.

Value: a sequence of octets

[default] Empty (zero-sized)

[range] Octet sequence of length [0,max_length]

TopicProtocolQosPolicy

type TopicProtocolQosPolicy is limited record
      Vendor_Specific_Entity : Boolean := False;
   end record with
     Convention => C;

DomainParticipantProtocolQosPolicy

type DomainParticipantProtocolQosPolicy is limited record
      Vendor_Specific_Entity : Boolean := False;
   end record with
     Convention => C;

DurabilityQosPolicyKind

type DurabilityQosPolicyKind is new Unsigned_Long;

Summary: Kinds of durability

QoS:
DDS.DurabilityQosPolicy

DurabilityQosPolicy

type DurabilityQosPolicy is record
      Kind                 : aliased DurabilityQosPolicyKind := VOLATILE_DURABILITY_QOS;
      Direct_Communication : aliased DDS.Boolean := True;
   end record with
     Convention => C;

Summary: This QoS policy specifies whether or not RTI Connext will store and deliver previously published data samples to new DDS.DataReader entities that join the network later.

Entity:
DDS.Topic, DDS.DataReader, DDS.DataWriter

Status:
DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

Properties:
"Rx0" = YES
"Changeable" = "UNTIL ENABLE"


See also: DDSDurabilityServiceQosModule

Usage

It is possible for a DDS.DataWriter to startpublishing data before all (or any) DDS.DataReader entities have joined the network.

Moreover, a DDS.DataReader that joins the network after some data has been written could potentially be interested in accessing the most current values of the data, as well as potentially some history.

This policy makes it possible for a late-joining DDS.DataReader to obtain previously published samples.

By helping to ensure that DataReaders get all data that was sent by DataWriters, regardless of when it was sent, using this QoS policy can increase system tolerance to failure conditions.

Note that although related, this does not strictly control what data RTI Connext will maintain internally. That is, RTI Connext may choose to maintain some data for its own purposes (e.g., flow control) and yet not make it available to late-joining readers if the DDSDurabilityQosModule policy is set to DDS.VOLATILE_DURABILITY_QOS.

Transient and Persistent Durability

For the purpose of implementing the DURABILITY QoS kind TRANSIENT or PERSISTENT, RTI Connext behaves as if for each Topic that has DDS.DurabilityQosPolicy.kind of DDS.TRANSIENT_DURABILITY_QOS or DDS.PERSISTENT_DURABILITY_QOS there is a corresponding "built-in" DDS.DataReader and DDS.DataWriter configured with the same DURABILITY kind. In other words, it is as if somewhere in the system, independent of the original DDS.DataWriter, there is a built-in durable DDS.DataReader subscribing to that Topic and a built-in durable DataWriter re-publishing it as needed for the new subscribers that join the system. This functionality is provided by the RTI Persistence Service.

The Persistence Service can configure itself based on the QoS of your application's DDS.DataWriter and DDS.DataReader entities. For each transient or persistent DDS.Topic, the built-in fictitious Persistence Service DDS.DataReader and DDS.DataWriter have their QoS configured from the QoS of your application's DDS.DataWriter and DDS.DataReader entities that communicate on that DDS.Topic.

For a given DDS.Topic, the usual request/offered semantics apply to the matching between any DDS.DataWriter in the domain that writes the DDS.Topic and the built-in transient/persistent DDS.DataReader for that DDS.Topic; similarly for the built-in transient/persistent DDS.DataWriter for a DDS.Topic and any DDS.DataReader for the DDS.Topic. As a consequence, a DDS.DataWriter that has an incompatible QoS will not send its data to the RTI Persistence Service, and a DDS.DataReader that has an incompatible QoS will not get data from it.

Incompatibilities between local DDS.DataReader and DDS.DataWriter entities and the corresponding fictitious built-in transient/persistent entities cause the DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS and DDS.OFFERED_INCOMPATIBLE_QOS_STATUS to change and the corresponding Listener invocations and/or signaling of DDS.Condition objects as they would with your application's own entities.

The value of DDS.DurabilityServiceQosPolicy.service_cleanup_delay controls when RTI Persistence Service is able to remove all information regarding a data instances.

Information on a data instance is maintained until the following conditions are met:

1. The instance has been explicitly disposed (instance_state = NOT_ALIVE_DISPOSED),

and

2. All samples for the disposed instance have been acknowledged, including the dispose sample itself,

and

3. A time interval longer that DDS.DurabilityServiceQosPolicy.service_cleanup_delay has elapsed since the moment RTI Connext detected that the previous two conditions were met. (Note: Only values of zero or DDS_DURATION_INFINITE are currently supported for the service_cleanup_delay)

The utility of DDS.DurabilityServiceQosPolicy.service_cleanup_delay is apparent in the situation where an application disposes an instance and it crashes before it has a chance to complete additional tasks related to the disposition. Upon restart, the application may ask for initial data to regain its state and the delay introduced by the service_cleanup_delay will allow the restarted application to receive the information on the disposed instance and complete the interrupted tasks.

Compatibility

The value offered is considered compatible with the value requested if and only if the inequality offered kind >= requested kind evaluates to 'TRUE'. For the purposes of this inequality, the values of DURABILITY kind are considered ordered such that DDS.VOLATILE_DURABILITY_QOS < DDS.TRANSIENT_LOCAL_DURABILITY_QOS < DDS.TRANSIENT_DURABILITY_QOS < DDS.PERSISTENT_DURABILITY_QOS.

Kind: The kind of durability.

[default] DDS.VOLATILE_DURABILITY_QOS

Direct_Communication: <<ext>> Indicates whether or not a TRANSIENT or PERSISTENT DDS.DataReader should receive samples directly from a TRANSIENT or PERSISTENT DDS.DataWriter

When direct_communication is set to DDS.BOOLEAN_TRUE, a TRANSIENT or PERSISTENT DDS.DataReader will receive samples from both the original DDS.DataWriter configured with TRANSIENT or PERSISTENT durability and the DDS.DataWriter created by the persistence service. This peer-to-peer communication pattern provides low latency between end-points.

If the same sample is received from the original DDS.DataWriter and the persistence service, the middleware will discard the duplicate.

When direct_communication is set to DDS.BOOLEAN_FALSE, a TRANSIENT or PERSISTENT DDS.DataReader will only receive samples from the DDS.DataWriter created by the persistence service. This brokered communication pattern provides a way to guarantee eventual consistency.

[default] DDS.BOOLEAN_TRUE

PresentationQosPolicyAccessScopeKind

type PresentationQosPolicyAccessScopeKind is new Unsigned_Long;

Summary: Kinds of presentation "access scope"

Access scope determines the largest scope spanning the entities for which the order and coherency of changes can be preserved.

QoS:
DDS.PresentationQosPolicy

PresentationQosPolicy

type PresentationQosPolicy  is record
      Access_Scope    : aliased PresentationQosPolicyAccessScopeKind := INSTANCE_PRESENTATION_QOS;
      Coherent_Access : aliased DDS.Boolean := False;
      Ordered_Access  : aliased DDS.Boolean := False;
   end record with
     Convention => C;

Summary: Specifies how the samples representing changes to data instances are presented to a subscribing application.

This QoS policy controls the extent to which changes to data instances can be made dependent on each other and also the kind of dependencies that can be propagated and maintained by dds. Specifically, this policy affects the application's ability to:

  • specify and receive coherent changes to instances
  • specify the relative order in which changes are presented

    Entity:
    DDS.Publisher, DDS.Subscriber

    Status:
    DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "UNTIL ENABLE"

    Usage

    A DDS.DataReader will usually receive data in the order that it was sent by a DDS.DataWriter, and the data is presented to the DDS.DataReader as soon as the application receives the next expected value. However, sometimes, you may want a set of data for the same DDS.DataWriter to be presented to the DDS.DataReader only after all of the elements of the set have been received. Or you may want the data to be presented in a different order than that in which it was received. Specifically for keyed data, you may want the middleware to present the data in keyed -- or instance -- order, such that samples pertaining to the same instance are presented together.

    The Presentation QoS policy allows you to specify different scopes of presentation: within a DDS.DataWriter, across instances of a single DDS.DataWriter, and even across multiple DataWriters used by different writers of a publisher. It also controls whether or not a set of changes within the scope is delivered at the same time or can be delivered as soon as each element is received.

  • coherent_access controls whether RTI Connext will preserve the groupings of changes made by a publishing application by means of the operations DDS.Publisher.begin_coherent_changes and DDS.Publisher.end_coherent_changes.

  • ordered_access controls whether RTI Connext will preserve the order of changes.

  • access_scope controls the granularity of the other settings. See below:

    If coherent_access is set, then the access_scope controls the maximum extent of coherent changes. The behavior is as follows:

  • If access_scope is set to DDS.INSTANCE_PRESENTATION_QOS (the default), the use of DDS.Publisher.begin_coherent_changes and DDS.Publisher.end_coherent_changes has no effect on how the subscriber can access the data, because with the scope limited to each instance, changes to separate instances are considered independent and thus cannot be grouped into a coherent set.

  • If access_scope is set to DDS.TOPIC_PRESENTATION_QOS, then coherent changes (indicated by their enclosure within calls to DDS.Publisher.begin_coherent_changes and DDS.Publisher.end_coherent_changes) will be made available as such to each remote DDS.DataReader independently. That is, changes made to instances within each individual DDS.DataWriter will be available as coherent with respect to other changes to instances in that same DDS.DataWriter, but will not be grouped with changes made to instances belonging to a different DDS.DataWriter.

  • If access_scope is set to DDS.GROUP_PRESENTATION_QOS, then coherent changes made to instances through a DDS.DataWriter attached to a common DDS.Publisher are made available as a unit to remote subscribers. (RTI does not currently support this access scope.)

    If ordered_access is set, then the access_scope controls the maximum extent for which order will be preserved by dds.

  • If access_scope is set to DDS.INSTANCE_PRESENTATION_QOS (the lowest level), then changes to each instance are considered unordered relative to changes to any other instance. That means that changes (creations, deletions, modifications) made to two instances are not necessarily seen in the order they occur. This is the case even if it is the same application thread making the changes using the same DDS.DataWriter.

  • If access_scope is set to DDS.TOPIC_PRESENTATION_QOS, changes (creations, deletions, modifications) made by a single DDS.DataWriter are made available to subscribers in the same order they occur. Changes made to instances though different DDS.DataWriter entities are not necessarily seen in the order they occur. This is the case, even if the changes are made by a single application thread using DDS.DataWriter objects attached to the same DDS.Publisher.

  • Finally, if access_scope is set to DDS.GROUP_PRESENTATION_QOS, changes made to instances via DDS.DataWriter entities attached to the same DDS.Publisher object are made available to subscribers on the same order they occur.

    Note that this QoS policy controls the scope at which related changes are made available to the subscriber. This means the subscriber can access the changes in a coherent manner and in the proper order; however, it does not necessarily imply that the DDS.Subscriber will indeed access the changes in the correct order. For that to occur, the application at the subscriber end must use the proper logic in reading the DDS.DataReader objects.

    For DDS.GROUP_PRESENTATION_QOS the subscribing application must use the APIs DDS.Subscriber.begin_access, DDS.Subscriber.end_access and DDS.Subscriber.get_datareaders to access the changes in the proper order.

    Compatibility

    The value offered is considered compatible with the value requested if and only if the following conditions are met:

  • the inequality offered access_scope >= requested access_scope evaluates to 'TRUE' or requested access_scope is DDS.HIGHEST_OFFERED_PRESENTATION_QOS. For the purposes of this inequality, the values of access_scope are considered ordered such that DDS.INSTANCE_PRESENTATION_QOS < DDS.TOPIC_PRESENTATION_QOS < DDS.GROUP_PRESENTATION_QOS.
  • requested coherent_access is DDS.BOOLEAN_FALSE, or else both offered and requested coherent_access are DDS.BOOLEAN_TRUE.
  • requested ordered_access is DDS.BOOLEAN_FALSE, or else both offered and requested ordered_access are DDS.BOOLEAN_TRUE.

    Access_Scope: Determines the largest scope spanning the entities for which the order and coherency of changes can be preserved.

    [default] DDS.INSTANCE_PRESENTATION_QOS

    Coherent_Access: Specifies support for coherent access. Controls whether coherent access is supported within the scope access_scope.

    That is, the ability to group a set of changes as a unit on the publishing end such that they are received as a unit at the subscribing end.

    Note: To use this feature, the DataWriter must be configured for RELIABLE communication (see DDS.RELIABLE_RELIABILITY_QOS).

    [default] DDS.BOOLEAN_FALSE

    Ordered_Access: Specifies support for ordered access to the samples received at the subscription end. Controls whether ordered access is supported within the scope access_scope.

    That is, the ability of the subscriber to see changes in the same order as they occurred on the publishing end.

    [default] DDS.BOOLEAN_FALSE

  • DeadlineQosPolicy

    type DeadlineQosPolicy is record
          Period : aliased Duration_T :=  DURATION_INFINITE;
       end record with
         Convention => C;

    Summary: Expresses the maximum duration (deadline) within which an instance is expected to be updated.

    A DDS.DataReader expects a new sample updating the value of each instance at least once every period. That is, period specifies the maximum expected elapsed time between arriving data samples.

    A DDS.DataWriter indicates that the application commits to write a new value (using the DDS.DataWriter) for each instance managed by the DDS.DataWriter at least once every period.

    This QoS can be used during system integration to ensure that applications have been coded to meet design specifications.

    It can also be used during run time to detect when systems are performing outside of design specifications. Receiving applications can take appropriate actions to prevent total system failure when data is not received in time. For topics on which data is not expected to be periodic, period should be set to an infinite value.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.OFFERED_DEADLINE_MISSED_STATUS, DDS.REQUESTED_DEADLINE_MISSED_STATUS, DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "YES"

    Usage

    This policy is useful for cases where a DDS.Topic is expected to have each instance updated periodically. On the publishing side this setting establishes a contract that the application must meet. On the subscribing side the setting establishes a minimum requirement for the remote publishers that are expected to supply the data values.

    When RTI Connext 'matches' a DDS.DataWriter and a DDS.DataReader it checks whether the settings are compatible (i.e., offered deadline <= requested deadline); if they are not, the two entities are informed (via the DDS.Listener or DDS.Condition mechanism) of the incompatibility of the QoS settings and communication will not occur.

    Assuming that the reader and writer ends have compatible settings, the fulfilment of this contract is monitored by RTI Connext and the application is informed of any violations by means of the proper DDS.Listener or DDS.Condition.

    Compatibility

    The value offered is considered compatible with the value requested if and only if the inequality offered period <= requested period holds.

    Consistency

    The setting of the DDSDeadlineQosModule policy must be set consistently with that of the DDSTimeBasedFilterQosModule.

    For these two policies to be consistent the settings must be such that deadline period >= minimum_separation.

    An attempt to set these policies in an inconsistent manner will result in DDS.RETCODE_INCONSISTENT_POLICY in Entity_set_qos, or the DDS.Entity will not be created.

    For a DDS.DataReader, the DDSDeadlineQosModule policy and DDS.TimeBasedFilterQosPolicy may interact such that even though the DDS.DataWriter is writing samples fast enough to fulfill its commitment to its own deadline, the DDS.DataReader may see violations of its deadline.This happens because RTI Connext will drop any samples received within the DDS.TimeBasedFilterQosPolicy.minimum_separation. To avoid triggering the DDS.DataReader's deadline, even though the matched DDS.DataWriter is meeting its own deadline, set the two QoS parameters so that:

    reader deadline >= reader minimum_separation + writer deadline

    See DDS.TimeBasedFilterQosPolicy for more information about the interactions between deadlines and time-based filters.


    See also: DDS.TimeBasedFilterQosPolicy

    Period: Duration of the deadline period.

    [default] DDS_DURATION_INFINITE

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE, >= DDS.TimeBasedFilterQosPolicy.minimum_separation

    LatencyBudgetQosPolicy

    type LatencyBudgetQosPolicy is record
          Duration : aliased Duration_T := DURATION_ZERO;
       end record with
         Convention => C;

    Summary: Provides a hint as to the maximum acceptable delay from the time the data is written to the time it is received by the subscribing applications.

    This policy is a hint to a DDS implementation; it can be used to change how it processes and sends data that has low latency requirements. The DDS specification does not mandate whether or how this policy is used.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "YES"


    See also: DDS.PublishModeQosPolicy
    See also: DDS.FlowController

    Usage

    This policy provides a means for the application to indicate to the middleware the urgency of the data communication. By having a non-zero duration, RTI Connext can optimize its internal operation.

    RTI Connext uses it in conjunction with DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS DDS.DataWriter instances associated with a DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY DDS.FlowController only. Together with the time of write, DDS.LatencyBudgetQosPolicy.duration determines the deadline of each individual sample. RTI Connext uses this information to prioritize the sending of asynchronously published data; see DDS.AsynchronousPublisherQosPolicy.

    Compatibility

    The value offered is considered compatible with the value requested if and only if the inequality offered duration <= requested duration evaluates to 'TRUE'.

    Duration: Duration of the maximum acceptable delay.

    [default] 0 (meaning minimize the delay)

    OwnershipQosPolicyKind

    type OwnershipQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of ownership

    QoS:
    DDS.OwnershipQosPolicy

    OwnershipQosPolicy

    type OwnershipQosPolicy is record
          Kind : aliased OwnershipQosPolicyKind := SHARED_OWNERSHIP_QOS;
       end record with
         Convention => C;

    Summary: Specifies whether it is allowed for multiple DDS.DataWriter (s) to write the same instance of the data and if so, how these modifications should be arbitrated.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "UNTIL ENABLE"


    See also: DDSOwnershipStrengthQosModule

    Usage

    Along with the DDSOwnershipStrengthQosModule, this QoS policy specifies if DDS.DataReader entities can receive updates to the same instance (identified by its key) from multiple DDS.DataWriter entities at the same time.

    There are two kinds of ownership, selected by the setting of the kind: SHARED and EXCLUSIVE.

    SHARED ownership

    DDS.SHARED_OWNERSHIP_QOS indicates that RTI Connext does not enforce unique ownership for each instance. In this case, multiple writers can update the same data type instance. The subscriber to the DDS.Topic will be able to access modifications from all DDS.DataWriter objects, subject to the settings of other QoS that may filter particular samples (e.g. the DDSTimeBasedFilterQosModule or DDSHistoryQosModule policy). In any case, there is no "filtering" of modifications made based on the identity of the DDS.DataWriter that causes the modification.

    EXCLUSIVE ownership

    DDS.EXCLUSIVE_OWNERSHIP_QOS indicates that each instance of a data type can only be modified by one DDS.DataWriter. In other words, at any point in time, a single DDS.DataWriter owns each instance and is the only one whose modifications will be visible to the DDS.DataReader objects. The owner is determined by selecting the DDS.DataWriter with the highest value of the DDS.OwnershipStrengthQosPolicy.value that is currently alive, as defined by the DDSLivelinessQosModule policy, and has not violated its DDSDeadlineQosModule contract with regards to the data instance.

    Ownership can therefore change as a result of:

  • a DDS.DataWriter in the system with a higher value of the strength that modifies the instance,
  • a change in the strength value of the DDS.DataWriter that owns the instance, and
  • a change in the liveliness of the DDS.DataWriter that owns the instance.
  • a deadline with regards to the instance that is missed by the DDS.DataWriter that owns the instance.

    The behavior of the system is as if the determination was made independently by each DDS.DataReader. Each DDS.DataReader may detect the change of ownership at a different time. It is not a requirement that at a particular point in time all the DDS.DataReader objects for that DDS.Topic have a consistent picture of who owns each instance.

    It is also not a requirement that the DDS.DataWriter objects are aware of whether they own a particular instance. There is no error or notification given to a DDS.DataWriter that modifies an instance it does not currently own.

    The requirements are chosen to (a) preserve the decoupling of publishers and subscriber, and (b) allow the policy to be implemented efficiently.

    It is possible that multiple DDS.DataWriter objects with the same strength modify the same instance. If this occurs RTI Connext will pick one of the DDS.DataWriter objects as the owner. It is not specified how the owner is selected. However, the algorithm used to select the owner guarantees that all DDS.DataReader objects will make the same choice of the particular DDS.DataWriter that is the owner. It also guarantees that the owner remains the same until there is a change in strength, liveliness, the owner misses a deadline on the instance, or a new DDS.DataWriter with higher same strength, or a new DDS.DataWriter with same strength that should be deemed the owner according to the policy of the Service, modifies the instance.

    Exclusive ownership is on an instance-by-instance basis. That is, a subscriber can receive values written by a lower strength DDS.DataWriter as long as they affect instances whose values have not been set by the higher-strength DDS.DataWriter.

    Compatibility

    The value of the DDS.OwnershipQosPolicyKind offered must exactly match the one requested or else they are considered incompatible.

    Relationship between registration, liveliness and ownership

    The need for registering/unregistering instances stems from two use cases:

  • Ownership resolution on redundant systems

  • Detection of loss in topological connectivity

    These two use cases also illustrate the semantic differences between the FooDataWriter.unregister_instance and FooDataWriter.dispose.

    Ownership Resolution on Redundant Systems

    It is expected that users may use DDS to set up redundant systems where multiple DDS.DataWriter entities are "capable" of writing the same instance. In this situation, the DDS.DataWriter entities are configured such that:

  • Either both are writing the instance "constantly"

  • Or else they use some mechanism to classify each other as "primary" and "secondary", such that the primary is the only one writing, and the secondary monitors the primary and only writes when it detects that the primary "writer" is no longer writing.

    Both cases above use the DDS.EXCLUSIVE_OWNERSHIP_QOS and arbitrate themselves by means of the DDS.OwnershipStrengthQosPolicy. Regardless of the scheme, the desired behavior from the DDS.DataReader point of view is that DDS.DataReader normally receives data from the primary unless the "primary" writer stops writing, in which case the DDS.DataReader starts to receive data from the secondary DDS.DataWriter.

    This approach requires some mechanism to detect that a DDS.DataWriter (the primary) is no longer "writing" the data as it should. There are several reasons why this may happen and all must be detected (but not necessarily distinguished):

  • [crash] The writing process is no longer running (e.g. the whole application has crashed)

  • [connectivity loss] Connectivity to the writing application has been lost (e.g. network disconnection)

  • [application fault] The application logic that was writing the data is faulty and has stopped calling FooDataWriter.write.

    Arbitrating from a DDS.DataWriter to one of a higher strength is simple and the decision can be taken autonomously by the DDS.DataReader. Switching ownership from a higher strength DDS.DataWriter to one of a lower strength DDS.DataWriter requires that the DDS.DataReader can make a determination that the stronger DDS.DataWriter is "no longer writing the instance".

    Case where the data is periodically updated

    This determination is reasonably simple when the data is being written periodically at some rate. The DDS.DataWriter simply states its offered DDS.DeadlineQosPolicy (maximum interval between updates) and the DDS.DataReader automatically monitors that the DDS.DataWriter indeed updates the instance at least once per DDS.DeadlineQosPolicy.period. If the deadline is missed, the DDS.DataReader considers the DDS.DataWriter "not alive" and automatically gives ownership to the next highest-strength DDS.DataWriter that is alive.

    Case where data is not periodically updated

    The case where the DDS.DataWriter is not writing data periodically is also a very important use-case. Since the instance is not being updated at any fixed period, the "deadline" mechanism cannot be used to determine ownership. The liveliness solves this situation. Ownership is maintained while the DDS.DataWriter is "alive" and for the DDS.DataWriter to be alive it must fulfill its DDS.LivelinessQosPolicy contract. The different means to renew liveliness (automatic, manual) combined by the implied renewal each time data is written handle the three conditions above [crash], [connectivity loss], and [application fault]. Note that to handle [application fault], LIVELINESS must be DDS.MANUAL_BY_TOPIC_LIVELINESS_QOS. The DDS.DataWriter can retain ownership by periodically writing data or else calling assert_liveliness if it has no data to write. Alternatively if only protection against [crash] or [connectivity loss] is desired, it is sufficient that some task on the DDS.DataWriter process periodically writes data or calls DDS.DomainParticipant.assert_liveliness. However, this scenario requires that the DDS.DataReader knows what instances are being "written" by the DDS.DataWriter. That is the only way that the DDS.DataReader deduces the ownership of specific instances from the fact that the DDS.DataWriter is still "alive". Hence the need for the DDS.DataWriter to "register" and "unregister" instances. Note that while "registration" can be done lazily the first time the DDS.DataWriter writes the instance, "unregistration," in general, cannot. Similar reasoning will lead to the fact that unregistration will also require a message to be sent to the DDS.DataReader.

    Detection of Loss in Topological Connectivity

    There are applications that are designed in such a way that their correct operation requires some minimal topological connectivity, that is, the writer needs to have a minimum number of readers or alternatively the reader must have a minimum number of writers.

    A common scenario is that the application does not start doing its logic until it knows that some specific writers have the minimum configured readers (e.g the alarm monitor is up).

    A more common scenario is that the application logic will wait until some writers appear that can provide some needed source of information (e.g. the raw sensor data that must be processed).

    Furthermore, once the application is running it is a requirement that this minimal connectivity (from the source of the data) is monitored and the application informed if it is ever lost. For the case where data is being written periodically, the DDS.DeadlineQosPolicy and the on_deadline_missed listener provides the notification. The case where data is not periodically updated requires the use of the DDS.LivelinessQosPolicy in combination with register_instance/unregister_instance to detect whether the "connectivity" has been lost, and the notification is provided by means of DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE.

    In terms of the required mechanisms, the scenario is very similar to the case of maintaining ownership. In both cases, the reader needs to know whether a writer is still "managing the current value of an instance" even though it is not continually writing it and this knowledge requires the writer to keep its liveliness plus some means to know which instances the writer is currently "managing" (i.e. the registered instances).

    Semantic Difference between unregister_instance and dispose

    FooDataWriter.dispose is semantically different from FooDataWriter.unregister_instance. FooDataWriter.dispose indicates that the data instance no longer exists (e.g. a track that has disappeared, a simulation entity that has been destroyed, a record entry that has been deleted, etc.) whereas FooDataWriter.unregister_instance indicates that the writer is no longer taking responsibility for updating the value of the instance.

    Deleting a DDS.DataWriter is equivalent to unregistering all the instances it was writing, but is not the same as "disposing" all the instances.

    For a DDS.Topic with DDS.EXCLUSIVE_OWNERSHIP_QOS, if the current owner of an instance disposes it, the readers accessing the instance will see the instance_state as being "DISPOSED" and not see the values being written by the weaker writer (even after the stronger one has disposed the instance). This is because the DDS.DataWriter that owns the instance is saying that the instance no longer exists (e.g. the master of the database is saying that a record has been deleted) and thus the readers should see it as such.

    For a DDS.Topic with DDS.EXCLUSIVE_OWNERSHIP_QOS, if the current owner of an instance unregisters it, then it will relinquish ownership of the instance and thus the readers may see the value updated by another writer (which will then become the owner). This is because the owner said that it no longer will be providing values for the instance and thus another writer can take ownership and provide those values.

    Kind: The kind of ownership

    [default] DDS.SHARED_OWNERSHIP_QOS

  • OwnershipStrengthQosPolicy

    type OwnershipStrengthQosPolicy is record
          Value : aliased Long := 0;
       end record with
         Convention => C;

    Summary: Specifies the value of the strength used to arbitrate among multiple DDS.DataWriter objects that attempt to modify the same instance of a data type (identified by DDS.Topic + key).

    This policy only applies if the DDSOwnershipQosModule policy is of kind DDS.EXCLUSIVE_OWNERSHIP_QOS.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "YES"

    The value of the DDSOwnershipStrengthQosModule is used to determine the ownership of a data instance (identified by the key). The arbitration is performed by the DDS.DataReader.


    See also: DDSOwnershipQosModule_usage_exclusive

    Value: The strength value used to arbitrate among multiple writers.

    [default] 0

    [range] [0, 1 million]

    LivelinessQosPolicyKind

    type LivelinessQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of liveliness

    QoS:
    DDS.LivelinessQosPolicy

    LivelinessQosPolicy

    type LivelinessQosPolicy is record
          Kind                          : aliased LivelinessQosPolicyKind := AUTOMATIC_LIVELINESS_QOS;
          Lease_Duration                : aliased Duration_T := DURATION_INFINITE;
          Assertions_Per_Lease_Duration : aliased Long := 3;
       end record with
         Convention => C;

    Summary: Specifies and configures the mechanism that allows DDS.DataReader entities to detect when DDS.DataWriter entities become disconnected or "dead."

    The liveliness status of a DDS.DataWriter is used to maintain instance ownership in combination with the setting of the DDSOwnershipQosModule policy. The application is also informed via DDS.Listener when an DDS.DataWriter is no longer alive.

    A DDS.DataWriter commits to signalling its liveliness at intervals not to exceed the DDS.LivelinessQosPolicy.lease_duration configured on the DDS.DataWriter. The rate at which the DDS.DataWriter will signal its liveliness is defined by DDS.LivelinessQosPolicy.assertions_per_lease_duration.

    The DDS.DataReader DDS.LivelinessQosPolicy.lease_duration specifies the maximum period at which matching DataWriters must have their liveliness asserted.

    In addition, in the subscribing application Connext DDS uses an internal thread that wakes up at the period set by the DataReaders lease_duration to see if a DataWriter lease_duration has been violated.

    Important: A DataReader will consider a DataWriter not alive if the DataWriter does not assert its liveliness within the DataWriter lease_duration not the DataReader lease_duration.

    Listeners are used to notify a DDS.DataReader of loss of liveliness and DDS.DataWriter of violations to the liveliness contract. The on_liveliness_lost() callback is only called once, after the first time the DDS.LivelinessQosPolicy.lease_duration is exceeded (when the DDS.DataWriter first loses liveliness).

    This QoS policy can be used during system integration to ensure that applications have been coded to meet design specifications. It can also be used during run time to detect when systems are performing outside of design specifications. Receiving applications can take appropriate actions in response to disconnected DataWriters.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.LIVELINESS_LOST_STATUS, DDS.LivelinessLostStatus;
    DDS.LIVELINESS_CHANGED_STATUS, DDS.LivelinessChangedStatus;
    DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS, DDS.OFFERED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "UNTIL ENABLE"

    Usage

    This policy controls the mechanism and parameters used by RTI Connext to ensure that particular DataWriters on the network are still alive. The liveliness can also affect the ownership of a particular instance, as determined by the DDSOwnershipQosModule policy.

    This policy has several settings to support both data types that are updated periodically as well as those that are changed sporadically. It also allows customisation for different application requirements in terms of the kinds of failures that will be detected by the liveliness mechanism.

    The DDS.AUTOMATIC_LIVELINESS_QOS liveliness setting is most appropriate for applications that only need to detect failures at the process-level, but not application-logic failures within a process. RTI Connext takes responsibility for renewing the leases at the required rates and thus, as long as the local process where a DDS.DomainParticipant is running and the link connecting it to remote participants remains connected, the entities within the DDS.DomainParticipant will be considered alive. This requires the lowest overhead.

    The manual settings (DDS.MANUAL_BY_PARTICIPANT_LIVELINESS_QOS, DDS.MANUAL_BY_TOPIC_LIVELINESS_QOS) require the application on the publishing side to periodically assert the liveliness before the lease expires to indicate the corresponding DDS.Entity is still alive. The action can be explicit by calling the DDS.DataWriter.assert_liveliness operation or implicit by writing some data.

    The two possible manual settings control the granularity at which the application must assert liveliness.

  • The setting DDS.MANUAL_BY_PARTICIPANT_LIVELINESS_QOS requires only that one DDS.Entity within a participant is asserted to be alive to deduce all other DDS.Entity objects within the same DDS.DomainParticipant are also alive.

  • The setting DDS.MANUAL_BY_TOPIC_LIVELINESS_QOS requires that at least one instance within the DDS.DataWriter is asserted.

    Changes in DDSLivelinessQosModule must be detected by the Service with a time-granularity greater or equal to the DDS.LivelinessQosPolicy.lease_duration. This ensures that the value of the DDS.LivelinessChangedStatus is updated at least once during each DDS.LivelinessQosPolicy.lease_duration and the related Listeners and DDS.WaitSet s are notified within a DDS.LivelinessQosPolicy.lease_duration from the time the DDSLivelinessQosModule changed.

    Compatibility

    The value offered is considered compatible with the value requested if and only if the following conditions are met:

  • the inequality offered kind >= requested kind evaluates to 'TRUE'. For the purposes of this inequality, the values of DDS.LivelinessQosPolicyKind kind are considered ordered such that: DDS.AUTOMATIC_LIVELINESS_QOS < DDS.MANUAL_BY_PARTICIPANT_LIVELINESS_QOS < DDS.MANUAL_BY_TOPIC_LIVELINESS_QOS.
  • the inequality offered lease_duration <= requested lease_duration evaluates to DDS.BOOLEAN_TRUE.


    See also: Registration_liveliness_ownership

    Kind: The kind of liveliness desired.

    [default] DDS.AUTOMATIC_LIVELINESS_QOS

    Lease_Duration: The duration within which a DDS.DataWriter must be asserted, or else it is assumed to be not alive.

    For a DataWriter, the lease_duration specifies a timeout by which liveliness must be asserted for the DataWriter or the DataWriter will be considered inactive or not alive.

    For a DataReader, the lease_duration specifies the maximum period at which the DataReader will check to see if the matching DataWriters are still alive according to the DataWriters lease_duration value.

    Important: A DataReader will consider a DataWriter not alive if it does not assert its liveliness within the DataWriter lease_duration not the DataReader lease_duration.

    [default] DDS_DURATION_INFINITE

    [range] [0,1 year] or DDS_DURATION_INFINITE

    Assertions_Per_Lease_Duration: The number of assertions a DDS.DataWriter will send during a its DDS.LivelinessQosPolicy.lease_duration.

    This field only applies to a DDS.DataWriter and is not considered during QoS compatibility checks.

    The default value is 3. A higher value will make the liveliness mechanism more robust against packet losses, but it will also increase the network traffic.

    [default] 3

    [range] [2, 100 million]

  • TimeBasedFilterQosPolicy

    type TimeBasedFilterQosPolicy is record
          Minimum_Separation : aliased Duration_T :=  DURATION_ZERO;
       end record with
         Convention => C;

    Summary: Filter that allows a DDS.DataReader to specify that it is interested only in (potentially) a subset of the values of the data.

    The filter states that the DDS.DataReader does not want to receive more than one value each minimum_separation, regardless of how fast the changes occur.

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "YES"

    Usage

    You can use this QoS policy to reduce the amount of data received by a DDS.DataReader. DDS.DataWriter entities may send data faster than needed by a DDS.DataReader. For example, a DDS.DataReader of sensor data that is displayed to a human operator in a GUI application does not need to receive data updates faster than a user can reasonably perceive changes in data values. This is often measured in tenths (0.1) of a second up to several seconds. However, a DDS.DataWriter of sensor information may have other DDS.DataReader entities that are processing the sensor information to control parts of the system and thus need new data updates in measures of hundredths (0.01) or thousandths (0.001) of a second.

    With this QoS policy, different DDS.DataReader entities can set their own time-based filters, so that data published faster than the period set by a each DDS.DataReader will not be delivered to that DDS.DataReader.

    The DDSTimeBasedFilterQosModule also applies to each instance separately; that is, the constraint is that the DDS.DataReader does not want to see more than one sample of each instance per minimum_separation period.

    This QoS policy allows you to optimize resource usage (CPU and possibly network bandwidth) by only delivering the required amount of data to each DDS.DataReader, accommodating the fact that, for rapidly-changing data, different subscribers may have different requirements and constraints as to how frequently they need or can handle being notified of the most current values. As such, it can also be used to protect applications that are running on a heterogeneous network where some nodes are capable of generating data much faster than others can consume it.

    For best effort data delivery, if the data type is unkeyed and the DDS.DataWriter has an infinite DDS.LivelinessQosPolicy.lease_duration, RTI Connext will only send as many packets to a DDS.DataReader as required by the TIME_BASED_FILTER, no matter how fast FooDataWriter.write is called.

    For multicast data delivery to multiple DataReaders, the one with the lowest minimum_separation determines the DataWriter's send rate. For example, if a DDS.DataWriter sends over multicast to two DataReaders, one with minimum_separation of 2 seconds and one with minimum_separation of 1 second, the DataWriter will send every 1 second.

    In configurations where RTI Connext must send all the data published by the DDS.DataWriter (for example, when the DDS.DataWriter is reliable, when the data type is keyed, or when the DDS.DataWriter has a finite DDS.LivelinessQosPolicy.lease_duration), only the data that passes the TIME_BASED_FILTER will be stored in the receive queue of the DDS.DataReader. Extra data will be accepted but dropped. Note that filtering is only applied on alive samples (that is, samples that have not been disposed/unregistered).

    Consistency

    It is inconsistent for a DDS.DataReader to have a minimum_separation longer than its DDSDeadlineQosModule period.

    However, it is important to be aware of certain edge cases that can occur when your publication rate, minimum separation, and deadline period align and that can cause missed deadlines that you may not expect. For example, suppose that you nominally publish samples every second but that this rate can vary somewhat over time. You declare a minimum separation of 1 second to filter out rapid updates and set a deadline of two seconds so that you will be aware if the rate falls too low. Even if your update rate never wavers, you can still miss deadlines! Here's why:

    Suppose you publish the first sample at time t=0 seconds. You then publish your next sample at t=1 seconds. Depending on how your operating system schedules the time-based filter execution relative to the publication, this second sample may be filtered. You then publish your third sample at t=2 seconds, and depending on how your OS schedules this publication in relation to the deadline check, you could miss the deadline.

    This scenario demonstrates a couple of rules of thumb:

  • Beware of setting your minimum_separation to a value very close to your publication rate: you may filter more data than you intend to.
  • Beware of setting your minimum_separation to a value that is too close to your deadline period relative to your publication rate. You may miss deadlines.

    See DDS.DeadlineQosPolicy for more information about the interactions between deadlines and time-based filters.

    The setting of a DDSTimeBasedFilterQosModule -- that is, the selection of a minimum_separation with a value greater than zero -- is consistent with all settings of the DDSHistoryQosModule and DDSReliabilityQosModule QoS. The DDSTimeBasedFilterQosModule specifies the samples that are of interest to the DDS.DataReader. The DDSHistoryQosModule and DDSReliabilityQosModule QoS affect the behavior of the middleware with respect to the samples that have been determined to be of interest to the DDS.DataReader; that is, they apply after the DDSTimeBasedFilterQosModule has been applied.

    In the case where the reliability QoS kind is DDS.RELIABLE_RELIABILITY_QOS, in steady-state -- defined as the situation where the DDS.DataWriter does not write new samples for a period "long" compared to the minimum_separation -- the system should guarantee delivery of the last sample to the DDS.DataReader.


    See also: DeadlineQosPolicy
    See also: HistoryQosPolicy
    See also: ReliabilityQosPolicy

    Minimum_Separation: The minimum separation duration between subsequent samples.

    [default] 0 (meaning the DDS.DataReader is potentially interested in all values)

    [range] [0,1 year], < DDS.DeadlineQosPolicy.period

  • PartitionQosPolicy

    type PartitionQosPolicy is record
          Name : aliased String_Seq.Sequence;
       end record with
         Convention => C;

    Summary: Set of strings that introduces a logical partition among the topics visible by a DDS.Publisher and a DDS.Subscriber.

    This QoS policy is used to set string identifiers that are used for matching DataReaders and DataWriters for the same Topic.

    A DDS.DataWriter within a DDS.Publisher only communicates with a DDS.DataReader in a DDS.Subscriber if (in addition to matching the DDS.Topic and having compatible QoS) the DDS.Publisher and DDS.Subscriber have a common partition name string.

    Entity:
    DDS.Publisher, DDS.Subscriber

    Properties:
    "Rx0" = NO
    "Changeable" = "YES"

    Usage

    This policy allows the introduction of a logical partition concept inside the 'physical' partition induced by a domain.

    Usually DataReaders and DataWriters are matched only by their topic (so that data are only sent by DataWriters to DataReaders for the same topic). The Partition QoS policy allows you to add one or more strings, "partitions", to a Publisher and/or Subscriber. If partitions are added, then a DataWriter and DataReader for the same topic are only considered matched if their Publishers and Subscribers have partitions in common (intersecting partitions).

    Since the set of partitions for a publisher or subscriber can be dynamically changed, the Partition QoS policy is useful to control which DataWriters can send data to which DataReaders and vice versa -- even if all of the DataWriters and DataReaders are for the same topic. This facility is useful for creating temporary separation groups among entities that would otherwise be connected to and exchange data each other.

    Failure to match partitions is not considered an incompatible QoS and does not trigger any listeners or conditions. A change in this policy can potentially modify the "match" of existing DataReader and DataWriter entities. It may establish new "matches" that did not exist before, or break existing matches.

    Partition strings are usually directly matched via string comparisons. However, partition strings can also contain wildcard symbols so that partitions can be matched via pattern matching. As long as the partitions or wildcard patterns of a Publisher intersect with the partitions or wildcard patterns of a Subscriber, their DataWriters and DataReaders of the same topic are able to match; otherwise they are not.

    These partition name patterns are regular expressions as defined by the POSIX fnmatch API (1003.2-1992 section B.6). Either DDS.Publisher or DDS.Subscriber may include regular expressions in partition names, but no two names that both contain wildcards will ever be considered to match. This means that although regular expressions may be used both at publisher as well as subscriber side, RTI Connext will not try to match two regular expressions (between publishers and subscribers).

    Each publisher and subscriber must belong to at least one logical partition. A regular expression is not considered to be a logical partition. If a publisher or subscriber has not specify a logical partition, it is assumed to be in the default partition. The default partition is defined to be an empty string (""). Put another way:

  • An empty sequence of strings in this QoS policy is considered equivalent to a sequence containing only a single string, the empty string.
  • A string sequence that contains only regular expressions and no literal strings, it is treated as if it had an additional element, the empty string.

    Partitions are different from creating DDS.Entity objects in different domains in several ways.

  • First, entities belonging to different domains are completely isolated from each other; there is no traffic, meta-traffic or any other way for an application or RTI Connext itself to see entities in a domain it does not belong to.
  • Second, a DDS.Entity can only belong to one domain whereas a DDS.Entity can be in multiple partitions.
  • Finally, as far as RTI Connext is concerned, each unique data instance is identified by the tuple (DomainID, DDS.Topic, key). Therefore two DDS.Entity objects in different domains cannot refer to the same data instance. On the other hand, the same data instance can be made available (published) or requested (subscribed) on one or more partitions.

    Name: A list of partition names

    Several restrictions apply to the partition names in this sequence. A violation of one of the following rules will result in a DDS.RETCODE_INCONSISTENT_POLICY when setting a DDS.Publisher's or DDS.Subscriber's QoS.

  • A partition name string cannot be NULL, nor can it contain the reserved comma character (',').

  • The maximum number of partition name strings allowable in a DDS.PartitionQosPolicy is specified on a domain basis in DDS.DomainParticipantResourceLimitsQosPolicy.max_partitions. The length of this sequence may not be greater than that value.

  • The maximum cumulative length of all partition name strings in a DDS.PartitionQosPolicy is specified on a domain basis in DDS.DomainParticipantResourceLimitsQosPolicy.max_partition_cumulative_characters.

    [default] Empty sequence (zero-length sequence). Since no logical partition is specified, RTI Connext will assume the entity to be in default partition (empty string partition "").

    [range] List of partition name with above restrictions

  • ReliabilityQosPolicyKind

    type ReliabilityQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of reliability

    QoS:
    DDS.ReliabilityQosPolicy

    ReliabilityQosPolicyAcknowledgmentModeKind

    type ReliabilityQosPolicyAcknowledgmentModeKind is new Unsigned_Long;

    Summary: <<ext>> Kinds of acknowledgment.

    QoS:
    DDS.ReliabilityQosPolicy

    ReliabilityQosPolicy

    type ReliabilityQosPolicy is record
          Kind                : aliased ReliabilityQosPolicyKind := BEST_EFFORT_RELIABILITY_QOS;
          Max_Blocking_Time   : aliased Duration_T := (0, 100_000_000);
          Acknowledgment_Kind : aliased ReliabilityQosPolicyAcknowledgmentModeKind := PROTOCOL_ACKNOWLEDGMENT_MODE;
       end record with
         Convention => C;

    Summary: Indicates the level of reliability offered/requested by dds.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "UNTIL ENABLE"

    Usage

    This policy indicates the level of reliability requested by a DDS.DataReader or offered by a DDS.DataWriter.

    The reliability of a connection between a DataWriter and DataReader is entirely user configurable. It can be done on a per DataWriter/DataReader connection. A connection may be configured to be "best effort" which means that RTI Connext will not use any resources to monitor or guarantee that the data sent by a DataWriter is received by a DataReader.

    For some use cases, such as the periodic update of sensor values to a GUI displaying the value to a person, DDS.BEST_EFFORT_RELIABILITY_QOS delivery is often good enough. It is certainly the fastest, most efficient, and least resource-intensive (CPU and network bandwidth) method of getting the newest/latest value for a topic from DataWriters to DataReaders. But there is no guarantee that the data sent will be received. It may be lost due to a variety of factors, including data loss by the physical transport such as wireless RF or even Ethernet.

    However, there are data streams (topics) in which you want an absolute guarantee that all data sent by a DataWriter is received reliably by DataReaders. This means that RTI Connext must check whether or not data was received, and repair any data that was lost by resending a copy of the data as many times as it takes for the DataReader to receive the data. RTI Connext uses a reliability protocol configured and tuned by these QoS policies: DDS.HistoryQosPolicy, DDS.DataWriterProtocolQosPolicy, DDS.DataReaderProtocolQosPolicy, and DDS.ResourceLimitsQosPolicy.

    The Reliability QoS policy is simply a switch to turn on the reliability protocol for a DataWriter/DataReader connection. The level of reliability provided by RTI Connext is determined by the configuration of the aforementioned QoS policies.

    You can configure RTI Connext to deliver all data in the order they were sent (also known as absolute or strict reliability). Or, as a tradeoff for less memory, CPU, and network usage, you can choose a reduced level of reliability where only the last N values are guaranteed to be delivered reliably to DataReaders (where N is user-configurable). In the reduced level of reliability, there are no guarantees that the data sent before the last N are received. Only the last N data packets are monitored and repaired if necessary.

    These levels are ordered, DDS.BEST_EFFORT_RELIABILITY_QOS < DDS.RELIABLE_RELIABILITY_QOS. A DDS.DataWriter offering one level is implicitly offering all levels below.

    Note: To send large data reliably, you will also need to set DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS. Large in this context means that the data cannot be sent as a single packet by the transport (for example, data larger than 63K when using UDP/IP).

    The setting of this policy has a dependency on the setting of the DDSResourceLimitsQosModule policy. In case the reliability kind is set to DDS.RELIABLE_RELIABILITY_QOS the write operation on the DDS.DataWriter may block if the modification would cause data to be lost or else cause one of the limits in specified in the DDSResourceLimitsQosModule to be exceeded. Under these circumstances, the DDSReliabilityQosModule max_blocking_time configures the maximum duration the write operation may block.

    If the DDS.ReliabilityQosPolicy.kind is set to DDS.RELIABLE_RELIABILITY_QOS, data samples originating from a single DDS.DataWriter cannot be made available to the DDS.DataReader if there are previous data samples that have not been received yet due to a communication error. In other words, RTI Connext will repair the error and resend data samples as needed in order to reconstruct a correct snapshot of the DDS.DataWriter history before it is accessible by the DDS.DataReader.

    If the DDS.ReliabilityQosPolicy.kind is set to DDS.BEST_EFFORT_RELIABILITY_QOS, the service will not re-transmit missing data samples. However, for data samples originating from any one DataWriter the service will ensure they are stored in the DDS.DataReader history in the same order they originated in the DDS.DataWriter. In other words, the DDS.DataReader may miss some data samples, but it will never see the value of a data object change from a newer value to an older value.


    See also: DDS.HistoryQosPolicy
    See also: DDS.ResourceLimitsQosPolicy

    Compatibility

    The value offered is considered compatible with the value requested if and only if:

  • the inequality offered kind >= requested kind evaluates to 'TRUE'. For the purposes of this inequality, the values of DDS.ReliabilityQosPolicy.kind are considered ordered such that DDS.BEST_EFFORT_RELIABILITY_QOS < DDS.RELIABLE_RELIABILITY_QOS.

  • The offered acknowledgment_kind = DDS.PROTOCOL_ACKNOWLEDGMENT_MODE and requested acknowledgment_kind = DDS.PROTOCOL_ACKNOWLEDGMENT_MODE OR offered acknowledgment_kind != DDS.PROTOCOL_ACKNOWLEDGMENT_MODE.

    Kind: Kind of reliability.

    [default] DDS.BEST_EFFORT_RELIABILITY_QOS for DDS.DataReader and DDS.Topic, DDS.RELIABLE_RELIABILITY_QOS for DDS.DataWriter

    Max_Blocking_Time: The maximum time a writer may block on a write() call.

    This setting applies only to the case where DDS.ReliabilityQosPolicy.kind = DDS.RELIABLE_RELIABILITY_QOS. FooDataWriter.write is allowed to block if the DDS.DataWriter does not have space to store the value written. Only applies to DDS.DataWriter.

    [default] 100 milliseconds

    [range] [0,1 year] or DDS_DURATION_INFINITE


    See also: DDS.ResourceLimitsQosPolicy

    Acknowledgment_Kind: <<ext>> Kind of reliable acknowledgment

    This setting applies only to the case where DDS.ReliabilityQosPolicy.kind = DDS.RELIABLE_RELIABILITY_QOS.

    Sets the kind acknowledgments supported by a DDS.DataWriter and sent by DDS.DataReader.

    [default] DDS.PROTOCOL_ACKNOWLEDGMENT_MODE

  • DestinationOrderQosPolicyKind

    type DestinationOrderQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of destination order

    QoS:
    DDS.DestinationOrderQosPolicy

    DestinationOrderQosPolicyScopeKind

    type DestinationOrderQosPolicyScopeKind is new Unsigned_Long;

    DestinationOrderQosPolicy

    type DestinationOrderQosPolicy is record
          Kind                       : aliased DestinationOrderQosPolicyKind := BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS;
          Scope                      : aliased DestinationOrderQosPolicyScopeKind := INSTANCE_SCOPE_DESTINATIONORDER_QOS;
          Source_Timestamp_Tolerance : aliased Duration_T := DURATION_ZERO;
       end record;

    Summary: Controls how the middleware will deal with data sent by multiple DDS.DataWriter entities for the same instance of data (i.e., same DDS.Topic and key).

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.OFFERED_INCOMPATIBLE_QOS_STATUS, DDS.REQUESTED_INCOMPATIBLE_QOS_STATUS

    Properties:
    "Rx0" = YES
    "Changeable" = "UNTIL ENABLE"

    Usage

    When multiple DataWriters send data for the same topic, the order in which data from different DataWriters are received by the applications of different DataReaders may be different. So different DataReaders may not receive the same "last" value when DataWriters stop sending data.

    This QoS policy controls how each subscriber resolves the final value of a data instance that is written by multiple DDS.DataWriter entities (which may be associated with different DDS.Publisher entities) running on different nodes.

    The default setting, DDS.BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS, indicates that (assuming the DDSOwnershipStrengthQosModule policy allows it) the latest received value for the instance should be the one whose value is kept. That is, data will be delivered by a DDS.DataReader in the order in which it was received (which may lead to inconsistent final values).

    The setting DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS indicates that (assuming the DDSOwnershipStrengthQosModule allows it, within each instance) the source_timestamp of the change shall be used to determine the most recent information. That is, data will be delivered by a DDS.DataReader in the order in which it was sent. If data arrives on the network with a source timestamp that is later than the source timestamp of the last data delivered, the new data will be dropped. This 'by source timestamp' ordering therefore works best when system clocks are relatively synchronized among writing machines.

    When using DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS, not all data sent by multiple DDS.DataWriter entities may be delivered to a DDS.DataReader and not all DataReaders will see the same data sent by DataWriters. However, all DataReaders will see the same "final" data when DataWriters "stop" sending data. This is the only setting that, in the case of concurrently publishing DDS.DataWriter entities updating the same instance of a shared-ownership topic, ensures all subscribers will end up with the same final value for the instance.

    This QoS can be used to create systems that have the property of "eventual consistency." Thus intermediate states across multiple applications may be inconsistent, but when DataWriters stop sending changes to the same topic, all applications will end up having the same state.

    Compatibility

    The value offered is considered compatible with the value requested if and only if the inequality offered kind >= requested kind evaluates to 'TRUE'. For the purposes of this inequality, the values of DDS.DestinationOrderQosPolicy.kind are considered ordered such that DDS.BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS < DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS

    Kind: Specifies the desired kind of destination order.

    [default] DDS.BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,

    source_timestamp_tolerance: <<ext>> Allowed tolerance between source timestamps of consecutive samples.

    When a DDS.DataWriter sets DDS.DestinationOrderQosPolicyKind to DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS, when writing a sample, its timestamp must not be less than the timestamp of the previously written sample. However, if it is less than the timestamp of the previously written sample but the difference is less than this tolerance, the sample will use the previously written sample's timestamp as its timestamp. Otherwise, if the difference is greater than this tolerance, the write will fail.

    When a DDS.DataReader sets DDS.DestinationOrderQosPolicyKind to DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS, the DDS.DataReader will accept a sample only if the source timestamp is no farther in the future from the reception timestamp than this tolerance. Otherwise, the sample is rejected.

    [default] 100 milliseconds for DDS.DataWriter, 30 seconds for DDS.DataReader \if CPP2_LANGUAGE_ONLY and when default-constructed\endif

    HistoryQosPolicyKind

    type HistoryQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of history

    QoS:
    DDS.HistoryQosPolicy

    RefilterQosPolicyKind

    type RefilterQosPolicyKind is new Unsigned_Long;

    Summary: <<ext>> Kinds of Refiltering

    QoS:
    DDS.HistoryQosPolicy

    HistoryQosPolicy

    type HistoryQosPolicy is record
          Kind     : aliased HistoryQosPolicyKind := KEEP_LAST_HISTORY_QOS;
          Depth    : aliased Long := 1;
          Refilter : aliased RefilterQosPolicyKind := NONE_REFILTER_QOS;
       end record with
         Convention => C;

    Summary: Specifies the behavior of RTI Connext in the case where the value of a sample changes (one or more times) before it can be successfully communicated to one or more existing subscribers.

    This QoS policy specifies how much data must to stored by RTI Connext for a DDS.DataWriter or DDS.DataReader. It controls whether RTI Connext should deliver only the most recent value, attempt to deliver all intermediate values, or do something in between.

    On the publishing side, this QoS policy controls the samples that should be maintained by the DDS.DataWriter on behalf of existing DDS.DataReader entities. The behavior with regards to a DDS.DataReader entities discovered after a sample is written is controlled by the DDSDurabilityQosModule policy.

    On the subscribing side, this QoS policy controls the samples that should be maintained until the application "takes" them from dds.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = NO
    "Changeable" = "UNTIL ENABLE"


    See also: DDS.ReliabilityQosPolicy
    See also: DDS.HistoryQosPolicy

    Usage

    This policy controls the behavior of RTI Connext when the value of an instance changes before it is finally communicated to DDS.DataReader entities.

    When a DDS.DataWriter sends data, or a DDS.DataReader receives data, the data sent or received is stored in a cache whose contents are controlled by this QoS policy. This QoS policy interacts with DDS.ReliabilityQosPolicy by controlling whether RTI Connext guarantees that all of the sent data is received (DDS.KEEP_ALL_HISTORY_QOS) or if only the last N data values sent are guaranteed to be received (DDS.KEEP_ALL_HISTORY_QOS)--this is a reduced level of reliability.

    The amount of data that is sent to new DataReaders who have configured their DDS.DurabilityQosPolicy to receive previously published data is also controlled by the History QoS policy.

    Note that the History QoS policy does not control the physical sizes of the send and receive queues. The memory allocation for the queues is controlled by the DDS.ResourceLimitsQosPolicy.

    If kind is DDS.KEEP_LAST_HISTORY_QOS (the default), then RTI Connext will only attempt to keep the latest values of the instance and discard the older ones. In this case, the value of depth regulates the maximum number of values (up to and including the most current one) RTI Connext will maintain and deliver. After N values have been sent or received, any new data will overwrite the oldest data in the queue. Thus the queue acts like a circular buffer of length N.

    For keyed-data, there is different behavior on the publishing and subscribing sides associated with how invalid samples representing the disposal or unregistration of an instance affect history.

    On the publishing side, unregistering or disposing an instance creates an invalid sample that is accounted for in the history depth. This means that an invalid sample may replace a value that is currently being stored in the writer queue.

    On the subscribing side, however, invalid samples do not count towards history depth and will not replace a value that is being stored in the reader queue.

    On both the publishing and subscribing sides, there can only ever be one invalid sample per-instance and that one sample can be in different states depending on whether the instance has been disposed, unregistered, or both.

    The default (and most common setting) for depth is 1, indicating that only the most recent value should be delivered.

    If kind is DDS.KEEP_ALL_HISTORY_QOS, then RTI Connext will attempt to maintain and deliver all the values of the instance to existing subscribers. The resources that RTI Connext can use to keep this history are limited by the settings of the DDSResourceLimitsQosModule. If the limit is reached, then the behavior of RTI Connext will depend on the DDSReliabilityQosModule. If the Reliability kind is DDS.BEST_EFFORT_RELIABILITY_QOS, then the old values will be discarded. If Reliability kind is RELIABLE, then RTI Connext will block the DDS.DataWriter until it can deliver the necessary old values to all subscribers.

    If refilter is DDS.NONE_REFILTER_QOS, then samples written before a DataReader is matched to a DataWriter are not refiltered by the DataWriter.

    If refilter is DDS.ALL_REFILTER_QOS, then all samples written before a DataReader is matched to a DataWriter are refiltered by the DataWriter when the DataReader is matched.

    If refilter is DDS.ON_DEMAND_REFILTER_QOS, then a DataWriter will only refilter samples that a DataReader requests.

    Consistency

    This QoS policy's depth must be consistent with the DDSResourceLimitsQosModule max_samples_per_instance. For these two QoS to be consistent, they must verify that depth <= max_samples_per_instance.


    See also: DDS.ResourceLimitsQosPolicy

    Kind: Specifies the kind of history to be kept.

    [default] DDS.KEEP_LAST_HISTORY_QOS

    Depth: Specifies the number of samples to be kept, when the kind is DDS.KEEP_LAST_HISTORY_QOS

    If a value other than 1 (the default) is specified, it should be consistent with the settings of the DDSResourceLimitsQosModule policy. That is:

    depth <= DDS.ResourceLimitsQosPolicy.max_samples_per_instance

    When the kind is DDS.KEEP_ALL_HISTORY_QOS, the depth has no effect. Its implied value is infinity (in practice limited by the settings of the DDSResourceLimitsQosModule policy).

    [default] 1

    [range] [1,100 million], <= DDS.ResourceLimitsQosPolicy.max_samples_per_instance

    Refilter: <<ext>> Specifies how a writer should handle previously written samples to a new reader.

    [default] DDS.NONE_REFILTER_QOS

    DurabilityServiceQosPolicy

    type DurabilityServiceQosPolicy is record
          Service_Cleanup_Delay    : aliased Duration_T := DURATION_ZERO;
          History_Kind             : aliased HistoryQosPolicyKind := KEEP_LAST_HISTORY_QOS;
          History_Depth            : aliased Long := 1;
          Max_Samples              : aliased Long := LENGTH_UNLIMITED;
          Max_Instances            : aliased Long := LENGTH_UNLIMITED;
          Max_Samples_Per_Instance : aliased Long := LENGTH_UNLIMITED;
       end record with
         Convention => C;

    Summary: Various settings to configure the external RTI Persistence Service used by RTI Connext for DataWriters with a DDS.DurabilityQosPolicy setting of DDS.PERSISTENT_DURABILITY_QOS or DDS.TRANSIENT_DURABILITY_QOS.

    Entity:
    DDS.Topic, DDS.DataWriter

    Properties:
    "Rx0" = NO
    "Changeable" = "UNTIL ENABLE"


    See also: DDSDurabilityQosModule
    See also: DDSHistoryQosModule
    See also: DDSResourceLimitsQosModule

    Usage

    When a DataWriter's DDS.DurabilityQosPolicy.kind is DDS.PERSISTENT_DURABILITY_QOS or DDS.TRANSIENT_DURABILITY_QOS, an external service, the RTI Persistence Service, is used to store and possibly forward the data sent by the DDS.DataWriter to DDS.DataReader objects that are created after the data was initially sent.

    This QoS policy is used to configure certain parameters of the Persistence Service when it operates on the behalf of the DDS.DataWriter, such as how much data to store. For example, it configures the DDSHistoryQosModule and the DDSResourceLimitsQosModule used by the fictitious DataReader and DataWriter used by the Persistence Service. Note, however, that the Persistence Service itself may be configured to ignore these values and instead use values from its own configuration file.

    Service_Cleanup_Delay: Controls when the service is able to remove all information regarding a data instances.

    When the service cleanup delay is set to 0, disposed instances will be completely removed from the service. Only values of 0 and DDS_DURATION_INFINITE are currently supported.

    [default] 0

    History_Kind: The kind of history to apply in recouping durable data.

    [default] DDS.KEEP_LAST_HISTORY_QOS

    History_Depth: Part of history QoS policy to apply when feeding a late joiner.

    [default] 1

    Max_Samples: Part of resource limits QoS policy to apply when feeding a late joiner.

    [default] DDS.LENGTH_UNLIMITED

    Max_Instances: Part of resource limits QoS policy to apply when feeding a late joiner.

    [default] DDS.LENGTH_UNLIMITED

    Max_Samples_Per_Instance: Part of resource limits QoS policy to apply when feeding a late joiner.

    [default] DDS.LENGTH_UNLIMITED

    ResourceLimitsQosPolicy

    type ResourceLimitsQosPolicy is record
          Max_Samples              : aliased Long := LENGTH_UNLIMITED;
          Max_Instances            : aliased Long := LENGTH_UNLIMITED;
          Max_Samples_Per_Instance : aliased Long := LENGTH_UNLIMITED;
          Initial_Samples          : aliased Long := 32;
          Initial_Instances        : aliased Long := 32;
          Instance_Hash_Buckets    : aliased Long := 32;
       end record;

    Summary: Controls the amount of physical memory allocated for DDS entities, if dynamic allocations are allowed, and how they occur. Also controls memory usage among different instance values for keyed topics.

    Entity:
    DDS.Topic, DDS.DataReader, DDS.DataWriter

    Status:
    DDS.SAMPLE_REJECTED_STATUS, DDS.SampleRejectedStatus

    Properties:
    "Rx0" = NO
    "Changeable" = "UNTIL ENABLE"

    Usage

    This policy controls the resources that RTI Connext can use to meet the requirements imposed by the application and other QoS settings.

    For the reliability protocol (and DDS.DurabilityQosPolicy), this QoS policy determines the actual maximum queue size when the DDS.HistoryQosPolicy is set to DDS.KEEP_ALL_HISTORY_QOS.

    In general, this QoS policy is used to limit the amount of system memory that RTI Connext can allocate. For embedded real-time systems and safety-critical systems, pre-determination of maximum memory usage is often required. In addition, dynamic memory allocation could introduce non-deterministic latencies in time-critical paths.

    This QoS policy can be set such that an entity does not dynamically allocate any more memory after its initialization phase.

    If DDS.DataWriter objects are communicating samples faster than they are ultimately taken by the DDS.DataReader objects, the middleware will eventually hit against some of the QoS-imposed resource limits. Note that this may occur when just a single DDS.DataReader cannot keep up with its corresponding DDS.DataWriter. The behavior in this case depends on the setting for the DDSReliabilityQosModule. If reliability is DDS.BEST_EFFORT_RELIABILITY_QOS, then RTI Connext is allowed to drop samples. If the reliability is DDS.RELIABLE_RELIABILITY_QOS, RTI Connext will block the DDS.DataWriter or discard the sample at the DDS.DataReader in order not to lose existing samples.

    The constant DDS.LENGTH_UNLIMITED may be used to indicate the absence of a particular limit. For example setting DDS.ResourceLimitsQosPolicy.max_samples_per_instance to DDS.LENGTH_UNLIMITED will cause RTI Connext not to enforce this particular limit.

    If these resource limits are not set sufficiently, under certain circumstances the DDS.DataWriter may block on a write() call even though the DDS.HistoryQosPolicy is DDS.KEEP_LAST_HISTORY_QOS. To guarantee the writer does not block for DDS.KEEP_LAST_HISTORY_QOS, make sure the resource limits are set such that:

    max_samples >= max_instances * max_samples_per_instance


    See also: DDS.ReliabilityQosPolicy
    See also: DDS.HistoryQosPolicy

    Consistency

    The setting of DDS.ResourceLimitsQosPolicy.max_samples must be consistent with DDS.ResourceLimitsQosPolicy.max_samples_per_instance. For these two values to be consistent, it must be true that DDS.ResourceLimitsQosPolicy.max_samples >= DDS.ResourceLimitsQosPolicy.max_samples_per_instance. As described above, this limit will not be enforced if DDS.ResourceLimitsQosPolicy.max_samples_per_instance is set to DDS.LENGTH_UNLIMITED.

    The setting of DDSResourceLimitsQosModule max_samples_per_instance must be consistent with the DDSHistoryQosModule depth. For these two QoS to be consistent, it must be true that depth <= max_samples_per_instance.


    See also: DDS.HistoryQosPolicy

    Max_Samples: Represents the maximum samples the middleware can store for any one DDS.DataWriter (or DDS.DataReader).

    Specifies the maximum number of data samples a DDS.DataWriter (or DDS.DataReader) can manage across all the instances associated with it.

    For unkeyed types, this value has to be equal to max_samples_per_instance if max_samples_per_instance is not equal to DDS.LENGTH_UNLIMITED.

    When batching is enabled, the maximum number of data samples a DDS.DataWriter can manage will also be limited by DDS.DataWriterResourceLimitsQosPolicy.max_batches.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 100 million] or DDS.LENGTH_UNLIMITED, >= initial_samples, >= max_samples_per_instance, >= DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer or >= DDS.RtpsReliableWriterProtocol_t.heartbeats_per_max_samples

    For DDS.DataWriterQos max_samples >= DDS.RtpsReliableWriterProtocol_t.heartbeats_per_max_samples in DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer if batching is disabled.

    Max_Instances: Represents the maximum number of instances a DDS.DataWriter (or DDS.DataReader) can manage.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_instances

    Max_Samples_Per_Instance: Represents the maximum number of samples of any one instance a DDS.DataWriter (or DDS.DataReader) can manage.

    While an unkeyed type is logically considered as a single instance, for unkeyed types this value has to be equal to max_samples or DDS.LENGTH_UNLIMITED.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 100 million] or DDS.LENGTH_UNLIMITED, <= max_samples or DDS.LENGTH_UNLIMITED, >= DDS.HistoryQosPolicy.depth

    Initial_Samples: <<ext>> Represents the initial samples the middleware will store for any one DDS.DataWriter (or DDS.DataReader).

    Specifies the initial number of data samples a DDS.DataWriter (or DDS.DataReader) will manage across all the instances associated with it.

    [default] 32

    [range] [1,100 million], <= max_samples

    Initial_Instances: <<ext>> Represents the initial number of instances a DDS.DataWriter (or DDS.DataReader) will manage.

    [default] 32

    [range] [1,1 million], <= max_instances

    Instance_Hash_Buckets: <<ext>> Number of hash buckets for instances.

    The instance hash table facilitates instance lookup. A higher number of buckets decreases instance lookup time but increases the memory usage.

    [default] 1 [range] [1,1 million]

    TransportPriorityQosPolicy

    type TransportPriorityQosPolicy is record
          Value : aliased Long := 0;
       end record with
         Convention => C;

    Summary: This QoS policy allows the application to take advantage of transports that are capable of sending messages with different priorities.

    The Transport Priority QoS policy is optional and only supported on certain OSs and transports. It allows you to specify on a per-DataWriter or DataReader basis that the data sent by that endpoint is of a different priority.

    The DDS specification does not indicate how a DDS implementation should treat data of different priorities. It is often difficult or impossible for DDS implementations to treat data of higher priority differently than data of lower priority, especially when data is being sent (delivered to a physical transport) directly by the thread that called FooDataWriter.write. Also, many physical network transports themselves do not have a end-user controllable level of data packet priority.

    Entity:
    DDS.DataWriter, DDS.DataReader, DDS.Topic

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    In dds, for the NDDS_Transport_UDPv4_Plugin, the value set in the Transport Priority QoS policy is used in a setsockopt call to set the TOS (type of service) bits of the IPv4 header for datagrams sent by a DDS.DataWriter or DDS.DataReader. It is platform-dependent how and whether the setsockopt has an effect. On some platforms, such as Windows and Linux, external permissions must be given to the user application in order to set the TOS bits.

    When using the UDPv6 Transport, the value set in the Transport Priority QoS policy is mapped to the Traffic Class bits of the IPv6 header. Please see the Platform Notes for details whether this mapping is supported on your plaform.

    It is incorrect to assume that using the Transport Priority QoS policy will have any effect at all on the end-to-end delivery of data from a DDS.DataWriter and a DDS.DataReader. All network elements, including switches and routers must have the capability and be enabled to actually use the TOS bits to treat higher priority packets differently. Thus the ability to use the Transport Priority QoS policy must be designed and configured at a system level; just turning it on in an application may have no effect at all.

    Value: This policy is a hint to the infrastructureas to how to set the priority of the underlying transport used to send the data.

    You may choose any value within the range of a 32-bit signed integer; higher values indicate higher priority. However, any further interpretation of this policy is specific to a particular transport and a particular DDS implementation. For example, a particular transport is permitted to treat a range of priority values as equivalent to one another.

    [default] 0

    LifespanQosPolicy

    type LifespanQosPolicy is record
          Duration : aliased Duration_T := DURATION_INFINITE;
       end record with
         Convention => C;

    Summary: Specifies how long the data written by the DDS.DataWriter is considered valid.

    Each data sample written by the DDS.DataWriter has an associated expiration time beyond which the data should not be delivered to any application. Once the sample expires, the data will be removed from the DDS.DataReader caches as well as from the transient and persistent information caches.

    The expiration time of each sample from the DDS.DataWriter's cache is computed by adding the duration specified by this QoS policy to the time when the sample is added to the DDS.DataWriter's cache. This timestamp is not necessarily equal to the sample's source timestamp that can be provided by the user using the FooDataWriter.write_w_timestamp or FooDataWriter.write_w_params API.

    The expiration time of each sample from the DDS.DataReader's cache is computed by adding the duration to the reception timestamp.


    See also: FooDataWriter.write
    See also: FooDataWriter.write_w_timestamp

    Entity:
    DDS.Topic, DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "YES"

    Usage

    The Lifespan QoS policy can be used to control how much data is stored by dds. Even if it is configured to store "all" of the data sent or received for a topic (see DDS.HistoryQosPolicy), the total amount of data it stores may be limited by this QoS policy.

    You may also use this QoS policy to ensure that applications do not receive or act on data, commands or messages that are too old and have 'expired.'

    To avoid inconsistencies, multiple writers of the same instance should have the same lifespan.


    See also: DDS.SampleInfo.source_timestamp
    See also: DDS.SampleInfo.reception_timestamp

    Duration: Maximum duration for the data's validity.

    [default] DDS_DURATION_INFINITE

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE

    WriterDataLifecycleQosPolicy

    type WriterDataLifecycleQosPolicy is record
          Autodispose_Unregistered_Instances     : aliased DDS.Boolean := True;
          Autopurge_Unregistered_Instances_Delay : aliased DDS.Duration_T := DURATION_INFINITE;
          Autopurge_Disposed_Instances_Delay     : aliased DDS.Duration_T := DURATION_INFINITE;
       end record with
         Convention => C;

    Summary: Controls how a DDS.DataWriter handles the lifecycle of the instances (keys) that it is registered to manage.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "YES"

    Usage

    This policy determines how the DDS.DataWriter acts with regards to the lifecycle of the data instances it manages (data instances that have been either explicitly registered with the DDS.DataWriter or implicitly registered by directly writing the data).

    Since the deletion of a DataWriter automatically unregisters all data instances it manages, the setting of the autodispose_unregistered_instances flag will only determine whether instances are ultimately disposed when the DDS.DataWriter is deleted either directly by means of the DDS.Publisher.delete_datawriter operation or indirectly as a consequence of calling DDS.Publisher.delete_contained_entities or DDS.DomainParticipant.delete_contained_entities that contains the DataWriter.

    You may use FooDataWriter.unregister_instance to indicate that the DDS.DataWriter no longer wants to send data for a DDS.Topic.

    The behavior controlled by this QoS policy applies on a per instance (key) basis for keyed Topics, so that when a DDS.DataWriter unregisters an instance, RTI Connext can automatically also dispose that instance. This is the default behavior.

    In many cases where the ownership of a Topic is shared (see DDS.OwnershipQosPolicy), DataWriters may want to relinquish their ownership of a particular instance of the Topic to allow other DataWriters to send updates for the value of that instance regardless of Ownership Strength. In that case, you may only want a DataWriter to unregister an instance without disposing the instance. Disposing an instance is a statement that an instance no longer exists. User applications may be coded to trigger on the disposal of instances, thus the ability to unregister without disposing may be useful to properly maintain the semantic of disposal.

    Autodispose_Unregistered_Instances: Boolean flag that controls the behavior when the DDS.DataWriter unregisters an instance by means of the unregister operations.

    • DDS.BOOLEAN_TRUE (default)
      The DDS.DataWriter will dispose the instance each time it is unregistered. The behavior is identical to explicitly calling one of the dispose operations on the instance prior to calling the unregister operation.
    • DDS.BOOLEAN_FALSE

      The DDS.DataWriter will not dispose the instance. The application can still call one of the dispose operations prior to unregistering the instance and accomplish the same effect.

    [default] DDS.BOOLEAN_TRUE

    Autopurge_Unregistered_Instances_Delay: <<ext>> Maximum duration for which the DDS.DataWriter will maintain information regarding an instance once it has unregistered the instance.

    Determines how long the DDS.DataWriter will maintain information regarding an instance that has been unregistered. By default, the DDS.DataWriter resources associated with an instance (e.g., the space needed to remember the Instance Key or KeyHash) are released lazily. This means the resources are only reclaimed when the space is needed for another instance because DDS.ResourceLimitsQosPolicy.max_instances is exceeded. This behavior can be changed by setting autopurge_unregistered_instance_delay to a value other than DDS_DURATION_INFINITE.

    After this time elapses, the DDS.DataWriter will purge all internal information regarding the instance, including historical samples, even if DDS.ResourceLimitsQosPolicy.max_instances has not been reached.

    [default] DDS_DURATION_INFINITE (disabled) for all DDS.DataWriter except for the built-in discovery DataWriters DDS_DURATION_ZERO for built-in discovery DataWriters (see DDS.DiscoveryConfigQosPolicy.publication_writer_data_lifecycle and DDS.DiscoveryConfigQosPolicy.subscription_writer_data_lifecycle).

    [range] [0, 1 year] or DDS_DURATION_INFINITE

    Autopurge_Disposed_Instances_Delay: <<ext>> Maximum duration for which the DDS.DataWriter will maintain information regarding an instance once it has disposed the instance.

    Determines how long the DDS.DataWriter will maintain information regarding an instance that has been disposed. By default, disposing an instance does not make it elegible to be purged. By setting autopurge_disposed_instance_delay to a value other than DDS_DURATION_INFINITE the DataWriter will delete the resources associated to an instance, including historical samples, once the time has elapsed and all matching DataReaders have acknowledged all the samples for this instance.

    [default] DDS_DURATION_INFINITE (disabled)

    [range] [0, 1 year] or DDS_DURATION_INFINITE (currently only 0 or DDS_DURATION_INFINITE are supported)

    ReaderDataLifecycleQosPolicy

    type ReaderDataLifecycleQosPolicy is record
          Autopurge_Nowriter_Samples_Delay   : aliased Duration_T := DURATION_INFINITE;
          Autopurge_Disposed_Samples_Delay   : aliased Duration_T := DURATION_INFINITE;
          Autopurge_Disposed_Instances_Delay : aliased Duration_T := DURATION_INFINITE;
       end record with
         Convention => C;

    Summary: Controls how a DataReader manages the lifecycle of the data that it has received.

    When a DataReader receives data, it is stored in a receive queue for the DataReader. The user application may either take the data from the queue or leave it there.

    This QoS policy controls whether or not RTI Connext will automatically remove data from the receive queue (so that user applications cannot access it afterwards) when it detects that there are no more DataWriters alive for that data. It specifies how long a DDS.DataReader must retain information regarding instances that have the instance_state DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE.

    Note: This policy is not concerned with keeping reliable reader state or discovery information.

    The DDS.DataReader internally maintains the samples that have not been "taken" by the application, subject to the constraints imposed by other QoS policies such as DDS.HistoryQosPolicy and DDS.ResourceLimitsQosPolicy.

    The DDS.DataReader also maintains information regarding the identity, view_state and instance_state of data instances even after all samples have been taken. This is needed to properly compute the states when future samples arrive.

    Under normal circumstances the DDS.DataReader can only reclaim all resources for instances for which there are no writers and for which all samples have been 'taken'. The last sample the DDS.DataReader will have taken for that instance will have an instance_state of either DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE or DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE depending on whether or not the last writer that had ownership of the instancedisposed it.

    In the absence of DDSReaderDataLifecycleQosModule, this behavior could cause problems if the application forgets to take those samples. "Untaken" samples will prevent the DDS.DataReader from reclaiming the resources and they would remain in the DDS.DataReader indefinitely.

    A DataReader can also reclaim all resources for instances that have an instance state of DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE and for which all DDS samples have been 'taken'. DataReaders will only reclaim resources in this situation when the autopurge_disposed_instances_delay has been set to zero.

    For keyed Topics, the consideration of removing data samples from the receive queue is done on a per instance (key) basis. Thus when RTI Connext detects that there are no longer DataWriters alive for a certain key value of a Topic (an instance of the Topic), it can be configured to remove all data samples for that instance (key).

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "YES"

    Autopurge_Nowriter_Samples_Delay: Minimum duration for which the DDS.DataReader will maintain information regarding an instance once its instance_state becomes DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE.

    At some point after this time elapses, the DDS.DataReader will purge all internal information regarding the instance, any "untaken" samples will also be lost.

    [default] DDS_DURATION_INFINITE

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE

    Autopurge_Disposed_Samples_Delay: Minimum duration for which the DDS.DataReader will maintain samples for an instance once its instance_state becomes DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE.

    At some point after this time elapses, the DDS.DataReader will purge all samples for the instance.

    [default] DDS_DURATION_INFINITE

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE

    Autopurge_Disposed_Instances_Delay: <<ext>> Minimum duration for which the DDS.DataReader will maintain an instance once its instance_state becomes DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE.

    At some point after this time elapses, the DDS.DataReader will purge all knowledge of the instance.

    The only currently supported values are 0 and DDS_DURATION_INFINITE. A value of 0 will purge an instance's state immediately after the instance state transitions to DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE, as long as all samples, including the dispose sample, associated with that instance have been 'taken'.

    [default] DDS_DURATION_INFINITE

    EntityFactoryQosPolicy

    type EntityFactoryQosPolicy is record
          Autoenable_Created_Entities : aliased DDS.Boolean := True;
       end record with
         Convention => C;

    Summary: A QoS policy for all DDS.Entity types that can act as factories for one or more other DDS.Entity types.

    Entity:
    DDS.DomainParticipantFactory, DDS.DomainParticipant, DDS.Publisher, DDS.Subscriber

    Properties:
    "Rx0" = NO
    "Changeable" = "YES"

    Usage

    This policy controls the behavior of the DDS.Entity as a factory for other entities.It controls whether or not child entities are created in the enabled state.

    RTI Connext uses a factory design pattern for creating DDS Entities. That is, a parent entity must be used to create child entities. DomainParticipants create Topics, Publishers and Subscribers. Publishers create DataWriters. Subscribers create DataReaders.

    By default, a child object is enabled upon creation (initialized and may be actively used). With this QoS policy, a child object can be created in a disabled state. A disabled entity is only partially initialized and cannot be used until the entity is enabled. Note: an entity can only be enabled; it cannot be disabled after it has been enabled.

    This QoS policy is useful to synchronize the initialization of DDS Entities. For example, when a DDS.DataReader is created in an enabled state, its existence is immediately propagated for discovery and the DDS.DataReader object's listener called as soon as data is received. The initialization process for an application may extend beyond the creation of the DDS.DataReader, and thus, it may not be desireable for the DDS.DataReader to start to receive or process any data until the initialization process is complete. So by creating readers in a disabled state, your application can make sure that no data is received until the rest of the application initialization is complete, and at that time, enable the them.

    Note: if an entity is disabled, then all of the child entities it creates will be disabled too, regardless of the setting of this QoS policy. However, enabling a disabled entity will enable all of its children if this QoS policy is set to automatically enable children entities.

    This policy is mutable. A change in the policy affects only the entities created after the change, not any previously created entities.

    Autoenable_Created_Entities: Specifies whether the entity acting as a factory automatically enables the instances it creates.

    The setting of autoenable_created_entities to DDS.BOOLEAN_TRUE indicates that the factory create_<entity> operation(s) will automatically invoke the DDS.Entity.enable operation each time a new DDS.Entity is created. Therefore, the DDS.Entity returned by create_<entity> will already be enabled. A setting of DDS.BOOLEAN_FALSE indicates that the DDS.Entity will not be automatically enabled. Your application will need to call DDS.Entity.enable itself.

    The default setting of autoenable_created_entities = DDS.BOOLEAN_TRUE means that, by default, it is not necessary to explicitly call DDS.Entity.enable on newly created entities.

    [default] DDS.BOOLEAN_TRUE

    AllocationSettings_T

    type AllocationSettings_T is record
          Initial_Count     : aliased Long := 0;
          Max_Count         : aliased Long := 0;
          Incremental_Count : aliased Long := 0;
       end record with
         Convention => C;

    Summary: Resource allocation settings.

    QoS:
    DDS.DomainParticipantResourceLimitsQosPolicy

    Initial_Count: The initial count of resources.

    The initial resources to be allocated.

    [default] It depends on the case.

    [range] [0, 1 million], < max_count, (or = max_count only if increment_count == 0)

    Max_Count: The maximum count of resources.

    The maximum resources to be allocated.

    [default] Depends on the case.

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, > initial_count (or = initial_count only if increment_count == 0)

    Incremental_Count: The incremental count of resources.

    The resource to be allocated when more resources are needed.

    [default] Depends on the case.

    [range] -1 (Double the amount of extra memory allocated each time memory is needed) or [1,1 million] (or = 0 only if initial_count == max_count)

    AllocationSettings_T_Access

    type  AllocationSettings_T_Access is access all  AllocationSettings_T;

    RtpsReliableReaderProtocol_T

    type RtpsReliableReaderProtocol_T is record
          Min_Heartbeat_Response_Delay       : aliased Duration_T := (0, 0);
          Max_Heartbeat_Response_Delay       : aliased Duration_T := (0, 500_000_000);
          Heartbeat_Suppression_Duration     : aliased Duration_T := (0, 62_500_000);
          Nack_Period                        : aliased Duration_T := (5, 0);
          Receive_Window_Size                : aliased Long := 256;
          Round_Trip_Time                    : aliased Duration_T := (0, 0);
          App_Ack_Period                     : aliased Duration_T := (5, 0);
          Min_App_Ack_Response_Keep_Duration : aliased Duration_T := (0, 0);
          Samples_Per_App_Ack                : aliased Long := 1;
       end record with Convention => C;

    Summary: Qos related to reliable reader protocol defined in RTPS.

    It is used to config reliable reader according to RTPS protocol.

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    QoS:
    DDS.DataReaderProtocolQosPolicy DDS.DiscoveryConfigQosPolicy

    Min_Heartbeat_Response_Delay: The minimum delay to respond to a heartbeat.

    When a reliable reader receives a heartbeat from a remote writerand finds out that it needs to send back an ACK/NACK message, the reader can choose to delay a while. This sets the value of the minimum delay.

    [default] 0 seconds

    [range] [0, 1 year], <= max_heartbeat_response_delay

    Max_Heartbeat_response_Delay: The maximum delay to respond to a heartbeat.

    When a reliable reader receives a heartbeat from a remote writer and finds out that it needs to send back an ACK/NACK message, the reader can choose to delay a while. This sets the value of maximum delay.

    [default] The default value depends on the container policy:

  • For DDS.DataReaderProtocolQosPolicy.rtps_reliable_reader: 0.5 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_reader: 0 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_reader: 0 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_reader: 0 seconds

    [range] [0, 1 year], >= min_heartbeat_response_delay

    Heartbeat_Suppression_Duration: The duration a reader ignores consecutively received heartbeats

    When a reliable reader receives consecutive heartbeats within a short duration that will trigger redundant NACKs, the reader may ignore the latter heartbeat(s). This sets the duration during which additionally received heartbeats are suppressed.

    [default] 0.0625 seconds

    [range] [0, 1 year],

    Nack_Period: The period at which to send NACKs

    A reliable reader will send periodic NACKs at this rate when it first matches with a reliable writer. The reader will stop sending NACKs when it has received all available historical data from the writer.

    [default] 5 seconds

    [range] [1 nanosec, 1 year]

    Receive_Window_Size: The number of received out-of-order samples a reader can keep at a time

    A reliable reader stores the out-of-order samples it receives until it can present them to the application in-order. The receive window is the maximum number of out-of-order samples that a reliable reader keeps at a given time. When the receive window is full, subsequently received out-of-order samples are dropped.

    [default] 256

    [range] [>= 1]

    Round_Trip_Time: The duration from sending a NACK to receiving a repair of a sample

    This round-trip time is an estimate of the time starting from when the reader sends a NACK for a specific sample to when it receives that sample. For each sample, the reader will not send a subsequent NACK for it until the round-trip time has passed, thus preventing inefficient redundant requests.

    [default] 0 seconds

    [range] [0 nanosec, 1 year]

    App_Ack_Period: The period at which application-level acknowledgment messages are sent

    A DDS.DataReader sends application-level acknowledgment messages to a DDS.DataWriter at this periodic rate, and will continue sending until it receives a message from the DDS.DataWriter that it has received and processed the acknowledgment and an AppAckConfirmation has been received by the DDS.DataReader. Note: application-level acknowledgment messages can also be sent non-periodically, as determined by DDS.RtpsReliableReaderProtocol_t.samples_per_app_ack.

    [default] 5 seconds

    [range] [1 nanosec, 1 year]

    Min_App_Ack_Response_Keep_Duration: Minimum duration for which application-level acknowledgment response data is kept

    The user-specified response data of an explicit application-level acknowledgment (called by DDS.DataReader.acknowledge_sample or DDS.DataReader.acknowledge_all) is cached by the DDS.DataReader for the purpose of reliably resending the data with the acknowledgment message. After this duration has passed from the time of the first acknowledgment, the response data is dropped from the cache and will not be resent with future acknowledgments for the corresponding sample(s).

    [default] 0 sec

    [range] [0 sec, 1 year]

    Samples_Per_App_Ack: The minimum number of samples acknowledged by one application-level acknowledgment message

    This setting applies only when DDS.ReliabilityQosPolicy.acknowledgment_kind = DDS.APPLICATION_EXPLICIT_ACKNOWLEDGMENT_MODE or DDS.APPLICATION_AUTO_ACKNOWLEDGMENT_MODE

    A DDS.DataReader will immediately send an application-level acknowledgment message when it has at least this many samples that have been acknowledged. It will not send an acknowledgment message until it has at least this many samples pending acknowledgment.

    For example, calling DDS.DataReader.acknowledge_sample this many times consecutively will trigger the sending of an acknowledgment message. Calling DDS.DataReader.acknowledge_all may trigger the sending of an acknowledgment message, if at least this many samples are being acknowledged at once.

    This is independent of the DDS.RtpsReliableReaderProtocol_t.app_ack_period, where a DDS.DataReader will send acknowledgement messages at the periodic rate regardless.

    When this is set to DDS.LENGTH_UNLIMITED, then acknowledgement messages are sent only periodically, at the rate set by DDS.RtpsReliableReaderProtocol_t.app_ack_period.

    [default] 1

    [range] [1, 1000000], or DDS.LENGTH_UNLIMITED

  • RtpsReliableWriterProtocol_T

    type RtpsReliableWriterProtocol_T is record -- RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT is default
          Low_Watermark                                                     : aliased Long := 0;
          High_Watermark                                                    : aliased Long := 1;
          Heartbeat_Period                                                  : aliased Duration_T := (3, 0);
          Fast_Heartbeat_Period                                             : aliased Duration_T := (3, 0);
          Late_Joiner_Heartbeat_Period                                      : aliased Duration_T := (3, 0);
          Virtual_Heartbeat_Period                                          : aliased Duration_T := DURATION_INFINITE;
          Samples_Per_Virtual_Heartbeat                                     : aliased Long := -1;
          Max_Heartbeat_Retries                                             : aliased Long := 10;
          Inactivate_Nonprogressing_Readers                                 : aliased Boolean := False;
          Heartbeats_Per_Max_Samples                                        : aliased Long := 8;
          Min_Nack_Response_Delay                                           : aliased Duration_T := (0, 0);
          Max_Nack_Response_Delay                                           : aliased Duration_T := (0, 200_000_000);
          Nack_Suppression_Duration                                         : aliased Duration_T := (0, 0);
          Max_Bytes_Per_Nack_Response                                       : aliased Long := 131072;
          Disable_Positive_Acks_Min_Sample_Keep_Duration                    : aliased Duration_T := (0, 1_000_000);
          Disable_Positive_Acks_Max_Sample_Keep_Duration                    : aliased Duration_T := (1, 0);
          Disable_Positive_Acks_Sample_Min_Separation                       : aliased Duration_T := (0, 1_000_000);
          Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration        : aliased Boolean := True;
          Disable_Positive_Acks_Enable_Spin_Wait                            : aliased Boolean := False;
          Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor        : aliased Long := 0;
          Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor        : aliased Long := 3;
          Min_Send_Window_Size                                              : aliased Long := 32;
          Max_Send_Window_Size                                              : aliased Long := 256;
          Send_Window_Update_Period                                         : aliased Duration_T := (3, 0);
          Send_Window_Increase_Factor                                       : aliased Long := 105;
          Send_Window_Decrease_Factor                                       : aliased Long := 70;
          Enable_Multicast_Periodic_Heartbeat                               : aliased Boolean := False;
          Multicast_Resend_Threshold                                        : aliased Long := 2;
       end record with
         Convention => C;

    Summary: QoS related to the reliable writer protocol defined in RTPS.

    It is used to configure a reliable writer according to RTPS protocol.

    The reliability protocol settings are applied to batches instead of individual data samples when batching is enabled.

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    QoS:
    DDS.DataWriterProtocolQosPolicy DDS.DiscoveryConfigQosPolicy

    low_watermark: When the number of unacknowledged samples in the current send window of a reliable writer meets or falls below this threshold, the DDS.RELIABLE_WRITER_CACHE_CHANGED_STATUS is considered to have changed.

    This value is measured in units of samples, except with batching configurations where it is measured in units of batches.

    The value must be greater than or equal to zero and strictly less than high_watermark.

    The high and low watermarks are used for switching between the regular and fast heartbeat rates (DDS.RtpsReliableWriterProtocol_t.heartbeat_period and DDS.RtpsReliableWriterProtocol_t.fast_heartbeat_period, respectively). When the number of unacknowledged samples in the queue of a reliable DDS.DataWriter meets or exceeds high_watermark, the DDS.RELIABLE_WRITER_CACHE_CHANGED_STATUS is changed, and the DataWriter will start heartbeating at DDS.RtpsReliableWriterProtocol_t.fast_heartbeat_period. When the number of samples meets or falls below low_watermark, DDS.RELIABLE_WRITER_CACHE_CHANGED_STATUS is changed, and the heartbeat rate will return to the "normal" rate (DDS.RtpsReliableWriterProtocol_t.heartbeat_period).

    [default] 0

    [range] [0, 100 million], < high_watermark

    high_watermark: When the number of unacknowledged samples in the current send window of a reliable writer meets or exceeds this threshold, the DDS.RELIABLE_WRITER_CACHE_CHANGED_STATUS is considered to have changed.

    This value is measured in units of samples, except with batching configurations where it is measured in units of batches.

    The value must be strictly greater than low_watermark and less than or equal to a maximum that depends on the container QoS policy:

    In DDS.DomainParticipantQos.discovery_config:

    For DDS.DiscoveryConfigQosPolicy.publication_writer
    high_watermark<= DDS.AllocationSettings_t.max_count in DDS.DomainParticipantResourceLimitsQosPolicy.local_writer_allocation

    For DDS.DiscoveryConfigQosPolicy.subscription_writer
    high_watermark<= DDS.AllocationSettings_t.max_count in DDS.DomainParticipantResourceLimitsQosPolicy.local_reader_allocation

    In DDS.DataWriterQos.protocol:

    For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer,

    high_watermark<=DDS.ResourceLimitsQosPolicy.max_samples if batching is disabled. Otherwise,
    high_watermark<=DDS.DataWriterResourceLimitsQosPolicy.max_batches high_watermark<=DDS.RtpsReliableWriterProtocol_t.max_send_window_size

    [default] 1

    [range] [1, 100 million] or DDS.LENGTH_UNLIMITED, > low_watermark <= maximum which depends on the container policy

    heartbeat_period: The period at which to send heartbeats.

    A reliable writer will send periodic heartbeats at this rate.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 1.0 seconds

    [range] [1 nanosec,1 year], >= DDS.RtpsReliableWriterProtocol_t.fast_heartbeat_period, >= DDS.RtpsReliableWriterProtocol_t.late_joiner_heartbeat_period

    fast_heartbeat_period: An alternative heartbeat period used when a reliable writer needs to flush its unacknowledged samples more quickly.

    This heartbeat period will be used when the number of unacknowledged samples in the cache of a reliable writer meets or exceeds the writer's high watermark and has not subsequently dropped to the low watermark. The normal period will be used at all other times.

    This period must not be slower (i.e. must be of the same or shorter duration) than the normal heartbeat period.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 1.0 seconds

    [range] [1 nanosec,1 year], <= DDS.RtpsReliableWriterProtocol_t.heartbeat_period

    late_joiner_heartbeat_period: An alternative heartbeat period used when a reliable reader joins late and needs to be caught up on cached samples of a reliable writer more quickly than the normal heartbeat rate.

    This heartbeat period will be used when a reliable reader joins after a reliable writer with non-volatile durability has begun publishing samples. Once the reliable reader has received all cached samples, it will be serviced at the same rate as other reliable readers.

    This period must not be slower (i.e. must be of the same or shorter duration) than the normal heartbeat period.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 3.0 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 1.0 seconds

    [range] [1 nanosec,1 year], <= DDS.RtpsReliableWriterProtocol_t.heartbeat_period

    virtual_heartbeat_period: The period at which to send virtual heartbeats. Virtual heartbeats inform the reliable reader about the range of samples currently present, for each virtual GUID, in the reliable writer's queue.

    A reliable writer will send periodic virtual heartbeats at this rate.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: DDS_DURATION_AUTO. If DDS.PresentationQosPolicy.access_scope is set to DDS.GROUP_PRESENTATION_QOS, this value is set to DDS.RtpsReliableWriterProtocol_t.heartbeat_period. Otherwise, the value is set to DDS_DURATION_INFINITE.
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: DDS_DURATION_INFINITE
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: DDS_DURATION_INFINITE
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: DDS_DURATION_INFINITE

    [range] > 1 nanosec, DDS_DURATION_INFINITE, or DDS_DURATION_AUTO

    samples_per_virtual_heartbeat: The number of samples that a reliable writer has to publish before sending a virtual heartbeat.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,1000000], DDS.LENGTH_UNLIMITED

    max_heartbeat_retries: The maximum number of periodic heartbeat retries before marking a remote reader as inactive.

    When a remote reader has not acked all the samples the reliable writer has in its queue, and max_heartbeat_retries number of periodic heartbeats has been sent without receiving any ack/nack back, the remote reader will be marked as inactive (not alive) and be ignored until it resumes sending ack/nack.

    Note that piggyback heartbeats do NOT count towards this value.

    [default] 10

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED

    inactivate_nonprogresing_readers: Whether to treat remote readers as inactive when their NACKs do not progress

    Nominally, a remote reader is marked inactive when a successive number of periodic heartbeats equal or greater than DDS.RtpsReliableWriterProtocol_t.max_heartbeat_retries have been sent without receiving any ack/nacks back.

    By setting this DDS.BOOLEAN_TRUE, it changes the conditions of inactivating a remote reader: a reader will be considered inactive when it either does not send any ack/nacks or keeps sending non-progressing nacks for DDS.RtpsReliableWriterProtocol_t.max_heartbeat_retries number of heartbeat periods, where a non-progressing nack is one whose oldest sample requested has not advanced from the oldest sample requested of the previous nack.

    [default] DDS.BOOLEAN_FALSE

    heartbeats_per_max_samples: The number of heartbeats per current send window.

    A piggyback heartbeat is sent every[(current send window size/heartbeats_per_max_samples)] number of samples written

    If set to zero, no piggyback heartbeat will be sent.

    If current send window size is DDS.LENGTH_UNLIMITED, 100 million is assumed as the value in the calculation.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 8
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 8
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 8
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 1

    [range] [0, 100 million]

  • For DDS.DiscoveryConfigQosPolicy.publication_writer:
    heartbeats_per_max_samples<= DDS.AllocationSettings_t.max_count in DDS.DomainParticipantResourceLimitsQosPolicy.local_writer_allocation

  • For DDS.DiscoveryConfigQosPolicy.subscription_writer:
    heartbeats_per_max_samples<= DDS.AllocationSettings_t.max_count in DDS.DomainParticipantResourceLimitsQosPolicy.local_reader_allocation

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer:

    heartbeats_per_max_samples<= DDS.ResourceLimitsQosPolicy.max_samples if batching is disabled. Otherwise:
    heartbeats_per_max_samples<= DDS.DataWriterResourceLimitsQosPolicy.max_batches

    heartbeats_per_max_samples<= DDS.RtpsReliableWriterProtocol_t.max_send_window_size

    min_nack_response_delay: The minimum delay to respond to a NACK.

    When a reliable writer receives a NACK from a remote reader, the writer can choose to delay a while before it sends repair samples or a heartbeat. This sets the value of the minimum delay.

    [default] 0 seconds

    [range] [0,1 day], <= max_nack_response_delay

    max_nack_response_delay: The maximum delay to respond to a nack.

    This set the value of maximum delay between receiving a NACK and sending repair samples or a heartbeat.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 0.2 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 0 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 0 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 0 seconds

    [range] [0,1 day], >= min_nack_response_delay

    nack_suppression_duration: The duration for ignoring consecutive NACKs that may trigger redundant repairs.

    A reliable writer may receive consecutive NACKs within a short duration from a remote reader that will trigger the sending of redundant repair messages.

    This specifies the duration during which consecutive NACKs are ignored to prevent redundant repairs from being sent.

    [default] 0 seconds

    [range] [0,1 day],

    max_bytes_per_nack_response: The maximum total message size when resending dropped samples.

    As part of the reliable communication protocol, data writers send heartbeat (HB) messages to their data readers. Each HB message contains the sequence number of the most recent sample sent by the data writer.

    In response, a data reader sends an acknowledgement (ACK) message, indicating what sequence numbers it did not receive, if any. If the data reader is missing some samples, the data writer will send them again.

    max_bytes_per_nack_response determines the maximum size of the message sent by the data writer in response to an ACK. This message may contain multiple samples. The data writer will always send at least one message, even if the size of that message exceeds the max_bytes_per_nack_response value.

    If max_bytes_per_nack_response is larger than the maximum message size supported by the underlying transport, RTI Connext will send multiple messages. If the total size of all samples that need to be resent is larger than max_bytes_per_nack_response, the remaining samples will be resent the next time an ACK arrives.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 131072 bytes
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 131072 bytes
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 131072 bytes
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 9216 bytes

    [range] [0, 1 GB]

    disable_positive_acks_min_sample_keep_duration: The minimum duration a sample is queued for ACK-disabled readers.

    When positive ACKs are disabled for a data writer (DDS.DataWriterProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE) or a data reader (DDS.DataReaderProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE), a sample is available from the data writer's queue for at least this duration, after which the sample may be considered to be acknowledged.

    [default] 1 millisecond

    [range] [0,1 year], <= DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_max_sample_keep_duration

    disable_positive_acks_max_sample_keep_duration: The maximum duration a sample is queued for ACK-disabled readers.

    When positive ACKs are disabled for a data writer (DDS.DataWriterProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE) or a data reader (DDS.DataReaderProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE), a sample is available from the data writer's queue for at most this duration, after which the sample is considered to be acknowledged.

    [default] 1 second

    [range] [0,1 year], >= DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_min_sample_keep_duration

    disable_positive_acks_enable_adaptive_sample_keep_duration: Enables dynamic adjustment of sample keep duration in response to congestion.

    For dynamic networks where a static minimum sample keep duration may not provide sufficient performance or reliability, setting DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_enable_adaptive_sample_keep_duration = DDS.BOOLEAN_TRUE, enables the sample keep duration to be dynamically adjusted to adapt to network conditions. The keep duration changes according to the detected level of congestion, which is determined to be proportional to the rate of NACKs received. An adaptive algorithm automatically controls the keep duration to optimize throughput and reliability.

    To relieve high congestion, the keep duration is increased to effectively decrease the send rate; this lengthening of the keep duration is controlled by DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_increase_sample_keep_duration_factor. Alternatively, when congestion is low, the keep duration is decreased to effectively increase send rate; this shortening of the keep duration is controlled by DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_decrease_sample_keep_duration_factor.

    The lower and upper bounds of the dynamic sample keep duration are set by DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_min_sample_keep_duration and DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_max_sample_keep_duration, respectively.

    When DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_enable_adaptive_sample_keep_duration = DDS.BOOLEAN_FALSE, the sample keep duration is set to DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_min_sample_keep_duration .

    [default] DDS.BOOLEAN_TRUE

    disable_positive_acks_enable_spin_wait: Enables spinning when write is blocked.

    Coarse timer resolutions can degrade performance of disabling ACKs, as sleeps used when writes are blocked cannot wake faster than the operating system allows.

    Enabling this replaces sleeping with spinning. On multi-core hosts, this can improve performance. Not recommended to be enabled for single-core hosts.

    [default] DDS.BOOLEAN_FALSE

    disable_positive_acks_decrease_sample_keep_duration_factor: Controls rate of contraction of dynamic sample keep duration.

    Used when DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_enable_adaptive_sample_keep_duration = DDS.BOOLEAN_TRUE.

    When the adaptive algorithm determines that the keep duration should be decreased, this factor (a percentage) is multiplied with the current keep duration to get the new shorter keep duration. For example, if the current keep duration is 20 milliseconds, using the default factor of 95% would result in a new keep duration of 19 milliseconds.

    [default] 95

    [range] <= 100

    disable_positive_acks_increase_sample_keep_duration_factor: Controls rate of growth of dynamic sample keep duration.

    Used when DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_enable_adaptive_sample_keep_duration = DDS.BOOLEAN_TRUE.

    When the adaptive algorithm determines that the keep duration should be increased, this factor (a percentage) is multiplied with the current keep duration to get the new longer keep duration. For example, if the current keep duration is 20 milliseconds, using the default factor of 150% would result in a new keep duration of 30 milliseconds.

    [default] 150

    [range] >= 100

    min_send_window_size: Minimum size of send window of unacknowledged samples

    A DDS.DataWriter has a limit on the number of unacknowledged samples in-flight at a time. This send window can be configured to have a minimum size (this field) and a maximum size (max_send_window_size). The send window can dynamically change, between the min and max sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

    [default] DDS.LENGTH_UNLIMITED

    [range] > 0, <= max_send_window_size, or DDS.LENGTH_UNLIMITED


    See also: DDS.RtpsReliableWriterProtocol_t.max_send_window_size
    See also: DDS.RtpsReliableWriterProtocol_t.low_watermark
    See also: DDS.RtpsReliableWriterProtocol_t.high_watermark
    See also: DDS.ReliableWriterCacheChangedStatus.full_reliable_writer_cache

    max_send_window_size: Maximum size of send window of unacknowledged samples

    A DDS.DataWriter has a limit on the number of unacknowledged samples in-flight at a time. This send window can be configured to have a minimum size (min_send_window_size) and a maximum size (this field). The send window can dynamically change, between the min and max sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

    When both min_send_window_size and max_send_window_size are DDS.LENGTH_UNLIMITED, then either DDS.ResourceLimitsQosPolicy.max_samples (for non-batching) or DDS.DataWriterResourceLimitsQosPolicy.max_batches (for batching) serves as the effective max_send_window_size. When DDS.ResourceLimitsQosPolicy.max_samples (for non-batching) or DDS.DataWriterResourceLimitsQosPolicy.max_batches (for batching) is less than max_send_window_size, then it serves as the effective max_send_window_size. If it is also less than min_send_window_size, then effectively both min and max send window sizes are equal to max_samples or max_batches.

    In addition, the low and high watermarks are scaled down linearly to stay within the current send window size, and the full reliable queue status is set when the send window is full.

    [default] DDS.LENGTH_UNLIMITED

    [range] > 0, >= min_send_window_size, or DDS.LENGTH_UNLIMITED


    See also: DDS.RtpsReliableWriterProtocol_t.min_send_window_size
    See also: DDS.RtpsReliableWriterProtocol_t.low_watermark
    See also: DDS.RtpsReliableWriterProtocol_t.high_watermark
    See also: DDS.ReliableWriterCacheChangedStatus.full_reliable_writer_cache

    send_window_update_period: Period in which send window may be dynamically changed

    The DDS.DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

    The change in send window size happens at this update period, whereupon the send window is either increased or decreased in size according to the increase or decrease factors, respectively.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 3 seconds
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 3 seconds
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 3 seconds
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 1 second

    [range] > [0,1 year]


    See also: DDS.RtpsReliableWriterProtocol_t.send_window_increase_factor, DDS.RtpsReliableWriterProtocol_t.send_window_decrease_factor

    send_window_increase_factor: Increases send window size by this percentage when reacting dynamically to network conditions

    The DDS.DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

    After an update period during which no negative acknowledgements were received, the send window will be increased by this factor. The factor is treated as a percentage, where a factor of 150 would increase the send window by 150%. The increased send window size will not exceed the max_send_window_size.

    [default] 105

    [range] > 100


    See also: DDS.RtpsReliableWriterProtocol_t.send_window_update_period, DDS.RtpsReliableWriterProtocol_t.send_window_decrease_factor

    send_window_decrease_factor: Decreases send window size by this percentage when reacting dynamically to network conditions

    The DDS.DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

    When increased network congestion causes a negative acknowledgement to be received by a writer, the send window will be decreased by this factor to throttle the effective send rate. The factor is treated as a percentage, where a factor of 80 would decrease the send window to 80% of its previous size. The decreased send window size will not be less than the min_send_window_size.

    [default] The default value depends on the container policy:

  • For DDS.DataWriterProtocolQosPolicy.rtps_reliable_writer: 70
  • For DDS.DiscoveryConfigQosPolicy.publication_writer: 50
  • For DDS.DiscoveryConfigQosPolicy.subscription_writer: 50
  • For DDS.DiscoveryConfigQosPolicy.participant_message_writer: 50

    [range] [0, 100]


    See also: DDS.RtpsReliableWriterProtocol_t.send_window_update_period, DDS.RtpsReliableWriterProtocol_t.send_window_increase_factor

    enable_multicast_periodic_heartbeat: Whether periodic heartbeat messages are sent over multicast

    When enabled, if a reader has a multicast destination, then the writer will send its periodic HEARTBEAT messages to that destination. Otherwise, if not enabled or the reader does not have a multicast destination, the writer will send its periodic HEARTBEATs over unicast.

    [default] DDS.BOOLEAN_FALSE

    multicast_resend_threshold: The minimum number of requesting readers needed to trigger a multicast resend

    Given readers with multicast destinations, when a reader NACKs for samples to be resent, the writer can either resend them over unicast or multicast. In order for the writer to resend over multicast, this threshold is the minimum number of readers of the same multicast group that the writer must receive NACKs from within a single response-delay. This allows the writer to coalesce near-simultaneous unicast resends into a multicast resend. Note that a threshold of 1 means that all resends will be sent over multicast, if available.

    [default] 2

    [range] [>= 1]

  • UserObjectSettings_T

    type UserObjectSettings_T is record
          Size      : aliased Long := 0;
          Alignment : aliased Long := 0;
       end record with
         Convention => C;

    TransportUnicastSettings_T

    type TransportUnicastSettings_T is record
          Transports   : aliased String_Seq.Sequence;
          Receive_Port : aliased Long := 0;
       end record with
         Convention => C;

    Summary: Type representing a list of unicast locators.

    A unicast locator specifies a transport class, a unicast address, and a unicast port number on which messages can be received by an entity.

    QoS:
    DDS.TransportUnicastQosPolicy

    Transport: A sequence of transport aliases that specifies the unicast interfaces on which to receive unicast traffic for the entity.

    Of the transport instances available to the entity, only those with aliases matching an alias on this sequence are used to determine the unicast interfaces used by the entity.

    Thus, this list of aliases sub-selects from the transports available to the entity.

    Each unicast interface on a transport results in a unicast locator for the entity.

    An empty sequence is a special value that specifies all the transports available to the entity.

    Alias names for the builtin transports are defined in DDSTransportBuiltinQosModule.

    [default] Empty sequence; i.e. all the transports available to the entity.
    [range] Any sequence of non-null, non-empty strings.

    Receive_Port: The unicast port on which the entity can receive data.

    Must be an unused unicast port on the system.

    [default] 0, which implies that the actual port number is determined by a formula as a function of the domain_id, and the DDS.WireProtocolQosPolicy.participant_id.

    [range] [0,0xffffffff]


    See also: DDS.WireProtocolQosPolicy.participant_id.

    TransportUnicastSettings_T_Access

    type TransportUnicastSettings_T_Access is access all TransportUnicastSettings_T;

    TransportUnicastSettings_T_Array

    type TransportUnicastSettings_T_Array is array
         (Natural range <>) of aliased TransportUnicastSettings_T;

    TransportMulticastSettings_T

    type TransportMulticastSettings_T is record
          Transports      : DDS.String_Seq.Sequence;
          Receive_Address : DDS.String;
          Receive_Port    : Long := 0;
       end record with
         Convention => C;

    Summary: Type representing a list of multicast locators.

    A multicast locator specifies a transport class, a multicast address, and a multicast port number on which messages can be received by an entity.

    QoS:
    DDS.TransportMulticastQosPolicy

    Transports: A sequence of transport aliases that specifies the transports on which to receive multicast traffic for the entity.

    Of the transport instances available to the entity, only those with aliases matching an alias in this sequence are used to subscribe to the multicast group addresses. Thus, this list of aliases sub-selects from the transport s available to the entity.

    An empty sequence is a special value that specifies all the transports available to the entity.

    Alias names for the builtin transports are defined in DDSTransportBuiltinQosModule.

    [default] Empty sequence; i.e. all the transports available to the entity.

    [range] Any sequence of non-null, non-empty strings.

    Receive_Address: The multicast group address on which the entity can receive data.

    Must must be an address in the proper format (see NDDS_DISCOVERY_PEERS_address_format).

    [default] NONE/INVALID. Required to specify a multicast group address to join.

    [range] A valid IPv4 or IPv6 multicast address.


    See also: NDDS_DISCOVERY_PEERS_address_format

    Receive_Port: The multicast port on which the entity can receive data.

    [default] 0, which implies that the actual port number is determined by a formula as a function of the domain_id (see DDS.WireProtocolQosPolicy.participant_id).

    [range] [0,0xffffffff]

    TransportMulticastSettings_T_Access

    type TransportMulticastSettings_T_Access is access all TransportMulticastSettings_T;

    TransportMulticastSettings_T_Array

    type TransportMulticastSettings_T_Array is array
         (Natural range <>) of aliased TransportMulticastSettings_T;

    TransportMulticastMappingFunction_T

    type TransportMulticastMappingFunction_T is record
          Dll             : DDS.String;
          Function_Name   : DDS.String;
       end record with
         Convention => C;

    Summary: Type representing an external mapping function

    A mapping function is defined by a dynamic library name and a function name.

    QoS:
    DDS.TransportMulticastMappingQosPolicy

    dll: Specifies a dynamic library that contains a mapping function.

    A relative or absolute path can be specified.

    If the name is specified as "foo", the library name on Linux systems will be libfoo.so; on Windows systems it will be foo.dll.

    [default] NULL

    function_name: Specifies the name of a mapping function.

    This function must be implemented in the library specified in DDS.TransportMulticastMappingFunction_t.dll.

    The function must implement the following interface:

    int function(const char* topic_name, int numberOfAddresses);

    The function must return an integer that indicates the index of the address to use for the given topic_name. For example, if the first address in the list should be used, it must return 0; if the second address in the list should be used, it must return 1, etc.

    TransportMulticastMapping_T

    type TransportMulticastMapping_T is record
          Addresses          : DDS.String;
          Topic_Expression   : DDS.String;
          Mapping_Function   : TransportMulticastMappingFunction_T;
       end record with
         Convention => C;

    Summary: Type representing a list of multicast mapping elements.

    A multicast mapping element specifies a string containing a list of IP addresses, a topic expression and a mapping function.

    QoS:
    DDS.TransportMulticastMappingQosPolicy

    addresses: A string containing a comma-separated list of IP addresses or IP address ranges to be used to receive multicast traffic for the entity with a topic that matches the DDS.TransportMulticastMapping_t.topic_expression.

    The string must contain IPv4 or IPv6 addresses separated by commas. For example: "239.255.100.1,239.255.100.2,239.255.100.3"

    You may specify ranges of addresses by enclosing the start address and the end address in square brackets. For example: "[239.255.100.1,239.255.100.3]"

    You may combine the two approaches. For example:

    "239.255.200.1,[239.255.100.1,239.255.100.3], 239.255.200.3"

    IPv4 addresses must be specified in Dot-decimal notation.

    IPv6 addresses must be specified using 8 groups of 16-bit hexadecimal values separated by colons. For example: FF00:0000:0000:0000:0202:B3FF:FE1E:8329

    Leading zeroes can be skipped. For example: "FF00:0:0:0:202:B3FF:FE1E:8329"

    You may replace a consecutive number of zeroes with a double colon, but only once within an address. For example: "FF00::202:B3FF:FE1E:8329"

    [default] NULL

    topic_expression: A regular expression that will be used to map topic names to corresponding multicast receive addresses.

    A topic name must match the expression before a corresponding address is assigned.

    [default] NULL

    mapping_function: Specifies a function that will define the mapping between a topic name and a specific multicast address from a list of addresses.

    This function is optional. If not specified, the middleware will use a hash function to perform the mapping.

    TransportMulticastMapping_T_Access

    type TransportMulticastMapping_T_Access is access all TransportMulticastMapping_T;

    TransportMulticastMapping_T_Array

    type TransportMulticastMapping_T_Array is array
         (Natural range <>) of aliased TransportMulticastMapping_T;

    EncapsulationId_T

    type EncapsulationId_T is new Unsigned_Short;

    EncapsulationId_T_Access

    type EncapsulationId_T_Access is access all EncapsulationId_T;

    EncapsulationId_T_Array

    type EncapsulationId_T_Array is array
         (Natural range <>) of aliased EncapsulationId_T;

    TransportEncapsulationSettings_T

    type TransportEncapsulationSettings_T is record
          Transports     : aliased DDS.String_Seq.Sequence;
          Encapsulations : aliased EncapsulationId_Seq.Sequence;
       end record with
         Convention => C;

    TransportEncapsulationSettings_T_Access

    type TransportEncapsulationSettings_T_Access is access all TransportEncapsulationSettings_T;

    TransportEncapsulationSettings_T_Array

    type TransportEncapsulationSettings_T_Array is array
         (Natural range <>) of aliased TransportEncapsulationSettings_T;

    TransportSelectionQosPolicy

    type TransportSelectionQosPolicy is record
          Enabled_Transports : aliased DDS.String_Seq.Sequence;
       end record with
         Convention => C;

    Summary: Specifies the physical transports a DDS.DataWriter or DDS.DataReader may use to send or receive data.

    An application may be simultaneously connected to many different physical transports, e.g., Ethernet, Infiniband, shared memory, VME backplane, and wireless. By default, RTI Connext will use up to \locator_list_max_size transports to deliver data from a DataWriter to a DataReader.

    This QoS policy can be used to both limit and control which of the application's available transports may be used by a DDS.DataWriter to send data or by a DDS.DataReader to receive data.

    Entity:
    DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Enabled_Transports: A sequence of transport aliases that specifies the transport instances available for use by the entity.

    Of the transport instances installed with the DDS.DomainParticipant, only those with aliases matching an alias in this sequence are available to the entity.

    Thus, this list of aliases sub-selects from the transports available to the DDS.DomainParticipant.

    An empty sequence is a special value that specifies all the transports installed with the DDS.DomainParticipant.

    Alias names for the builtin transports are defined in DDSTransportBuiltinQosModule.

    [default] Empty sequence; i.e. all the transports installed with and available to the DDS.DomainParticipant.

    [range] A sequence of \ifnot CPP2_LANGUAGE_ONLY non-null,\endif non-empty strings.


    See also: DDS.DomainParticipantQos.transport_builtin.

    TransportUnicastQosPolicy

    type TransportUnicastQosPolicy is record
          Value :  TransportUnicastSettings_Seq.Sequence;
       end record with
         Convention => C;

    Summary: Specifies a subset of transports and a port number that can be used by an Entity to receive data.

    Entity:
    DDS.DomainParticipant, DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    RTI Connext may send data to a variety of Entities, not just DataReaders. For example, reliable DataWriters may receive ACK/NACK packets from reliable DataReaders.

    During discovery, each DDS.Entity announces to remote applications a list of (up to \locator_list_max_size) unicast addresses to which the remote application should send data (either user data packets or reliable protocol meta-data such as ACK/NACKs and heartbeats). Note that this is a hard limit that cannot be increased. However, this limit can be decreased by configuring the 'dds.domain_participant.max_announced_locator_list_size' property in the DDS.PropertyQosPolicy associated with the DDS.DomainParticipantQos.

    By default, the list of addresses is populated automatically with values obtained from the enabled transport plug-ins allowed to be used by the Entity (see DDS.TransportBuiltinQosPolicy and DDS.TransportSelectionQosPolicy). Also, the associated ports are automatically determined (see DDS.RtpsWellKnownPorts_t).

    Use this QoS policy to manually set the receive address list for an Entity. You may optionally set a port to use a non-default receive port as well. Only the first \locator_list_max_size addresses will be used.

    RTI Connext will create a receive thread for every unique port number that it encounters (on a per transport basis).

  • For a DDS.DomainParticipant, this QoS policy sets the default list of addresses used by other applications to send user data for local DataReaders.

  • For a DDS.DataReader, if set, then other applications will use the specified list of addresses to send user data (and reliable protocol packets for reliable DataReaders). Otherwise, if not set, the other applications will use the addresses set by the DDS.DomainParticipant.

  • For a reliable DDS.DataWriter, if set, then other applications will use the specified list of addresses to send reliable protocol packets (ACKS/NACKS) on the behalf of reliable DataReaders. Otherwise, if not set, the other applications will use the addresses set by the DDS.DomainParticipant.

    Value: A sequence of unicast communication settings.

    An empty sequence means that applicable defaults specified by elsewhere (e.g. DDS.DomainParticipantQos.default_unicast) should be used.

    The RTPS wire protocol currently limits the maximum number of unicast locators to \locator_list_max_size. Note that this is a hard limit that cannot be increased. However, this limit can be decreased by configuring the 'dds.domain_participant.max_announced_locator_list_size' property in the DDS.PropertyQosPolicy associated with the DDS.DomainParticipantQos.

    [default] Empty sequence.


    See also: DDS.DomainParticipantQos.default_unicast

  • TransportMulticastQosPolicyKind

    type TransportMulticastQosPolicyKind is new Unsigned_Long;

    Summary: Transport Multicast Policy Kind


    See also: DDS.TransportMulticastQosPolicy

    TransportMulticastQosPolicy

    type TransportMulticastQosPolicy is record
          Value : TransportMulticastSettings_Seq.Sequence;
          Kind  : TransportMulticastQosPolicyKind := AUTOMATIC_TRANSPORT_MULTICAST_QOS;
       end record with
         Convention => C;

    Summary: Specifies the multicast address on which a DDS.DataReader wants to receive its data. It can also specify a port number as well as a subset of the available (at the DDS.DomainParticipant level) transports with which to receive the multicast data.

    By default, a DDS.DataWriter will send individually addressed packets for each DDS.DataReader that subscribes to the topic of the DataWriter -- this is known as unicast delivery. Thus, as many copies of the data will be sent over the network as there are DataReaders for the data. The network bandwidth used by a DataWriter will thus increase linearly with the number of DataReaders.

    Multicast addressing (on UDP/IP transports) allows multiple DataReaders to receive the same network packet. By using multicast, a DDS.DataWriter can send a single network packet that is received by all subscribing applications. Thus the network bandwidth usage will be constant, independent of the number of DataReaders.

    Coordinating the multicast address specified by DataReaders can help optimize network bandwidth usage in systems where there are multiple DataReaders for the same DDS.Topic.

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Value: A sequence of multicast communications settings.

    An empty sequence means that multicast is not used by the entity.

    The RTPS wire protocol currently limits the maximum number of multicast locators to \locator_list_max_size. Note that this is a hard limit that cannot be increased. However, this limit can be decreased by configuring the 'dds.domain_participant.max_announced_locator_list_size' property in the DDS.PropertyQosPolicy associated with the DDS.DomainParticipantQos.

    [default] Empty sequence.

    Kind: A value that specifies a way to determine how to obtain the multicast address.

    This field can be set to one of the following two values: DDS.AUTOMATIC_TRANSPORT_MULTICAST_QOS or DDS.UNICAST_ONLY_TRANSPORT_MULTICAST_QOS.

    • If it is set to DDS.AUTOMATIC_TRANSPORT_MULTICAST_QOS, the behavior will depend on the DDS.TransportMulticastQosPolicy.value:
      • If DDS.TransportMulticastQosPolicy.value does not have any elements, then multicast will not be used.
      • If DDS.TransportMulticastQosPolicy.value first element has an empty address, then the address will be obtained from DDS.TransportMulticastMappingQosPolicy.
      • If none of the elements in DDS.TransportMulticastQosPolicy.value is empty, and at least one element has a valid address, then that address will be used.
    • If it is set to DDS.UNICAST_ONLY_TRANSPORT_MULTICAST_QOS, then multicast will not be used.
    [default] DDS.AUTOMATIC_TRANSPORT_MULTICAST_QOS

    TransportMulticastMappingQosPolicy

    type TransportMulticastMappingQosPolicy is record
          Value : TransportMulticastMapping_Seq.Sequence;
       end record with
         Convention => C;

    Summary: Specifies a list of topic_expressions and multicast addresses that can be used by an Entity with a specific topic name to receive data.

    This QoS policy provides an alternate way to assign multicast receive addresses to DataReaders. It allows you to perform multicast configuration at the DDS.DomainParticipant level.

    To use multicast communication without this QoS policy, you must explicitly assign a multicast receive address on each DDS.DataReader. This can quickly become difficult to configure as more DataReaders of different topics and multicast addresses are added.

    With this QoS policy, you can configure a set of multicast addresses on the DDS.DomainParticipant; those addresses will then be automatically assigned to the DomainParticipant's DataReaders. A single configuration on the DDS.DomainParticipant can thus replace per-DataReader configuration.

    On the DomainParticipant, the set of assignable addresses can be configured for specific topics. Addresses are configured on topics because efficient usage of multicast will have all DataWriters and DataReaders of a single topic using the same multicast address.

    You can specify a mapping between a topic's name and a multicast address. For example, topic 'A' can be assigned to address 239.255.1.1 and topic 'B' can be assigned to address 239.255.1.2.

    You can use filter expressions to configure a subset of topics to use a specific list of addresses. For example, suppose topics "X", "Y" and "Z" need to be sent to any address within the range [239.255.1.1, 239.255.1.255]. You can specify an expression on the topic name (e.g. "[X-Z]") corresponding to that range of addresses. Then the DomainParticipant will select an address for a topic whose name matches the expression.

    The middleware will use a hash function to perform the mapping from topic to address. Alternatively, you can specify a pluggable mapping function.

    IMPORTANT: All the strings defined in each element of the sequence must be assigned using RTI_String_dup("foo");. For example:

    mcastMappingElement->addresses = DDS_String_dup("[239.255.1.1,239.255.1.255]");

    NOTE: To use this QoS policy, you must:

  • Set DDS.TransportMulticastQosPolicy.kind to DDS.AUTOMATIC_TRANSPORT_MULTICAST_QOS.
  • Set the first element in DDS.DataReader's DDS.TransportMulticastQosPolicy.value with an empty address.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Value: A sequence of multicast communication mappings.

    [default] Empty sequence.

  • TransportEncapsulationQosPolicy

    type TransportEncapsulationQosPolicy is record
          Value : aliased TransportEncapsulationSettings_Seq.Sequence;
       end record with
         Convention => C;

    DiscoveryQosPolicy

    type DiscoveryQosPolicy is record
          Enabled_Transports                          : aliased String_Seq.Sequence;
          Initial_Peers                               : aliased String_Seq.Sequence;
          Multicast_Receive_Addresses                 : aliased String_Seq.Sequence;
          Metatraffic_Transport_Priority              : aliased Long := 0;
          Accept_Unknown_Peers                        : aliased DDS.Boolean := True;
          Enable_Endpoint_Discovery                   : aliased DDS.Boolean := True;
       end record with
         Convention => C;

    Summary: <<ext>> Configures the mechanism used by the middleware to automatically discover and connect with new remote applications.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    This QoS policy identifies where on the network this application can potentially discover other applications with which to communicate.

    The middleware will periodically send network packets to these locations, announcing itself to any remote applications that may be present, and will listen for announcements from those applications.

    This QoS policy is an extension to the DDS standard.


    See also: NDDS_DISCOVERY_PEERS
    See also: DDS.DiscoveryConfigQosPolicy

    Enabled_Transports: The transports available for use by the Discovery mechanism.

    Only these transports can be used by the discovery mechanism to send meta-traffic via the builtin endpoints (built-in DDS.DataReader and DDS.DataWriter).

    Also determines the unicast addresses on which the Discovery mechanism will listen for meta-traffic. These along with the domain_id and participant_id determine the unicast locators on which the Discovery mechanism can receive meta-data.

    Alias names for the builtin transports are defined in DDSTransportBuiltinQosModule.

    [default] Empty sequence. All the transports available to the DomainParticipant are available for use by the Discovery mechanism.

    [range] Sequence of non-null,non-empty strings.

    Initial_Peers: Determines the initial list of peers that will be contacted by the Discovery mechanism to send announcements about the presence of this participant.

    As part of the participant discovery phase, the DDS.DomainParticipant will announce itself to the domain by sending participant DATA messages. The initial_peers specifies the initial list of peers that will be contacted. A remote DDS.DomainParticipant is discovered by receiving participant announcements from a remote peer. When the new remote DDS.DomainParticipant has been added to the participant's database, the endpoint discovery phase commences and information about the DataWriters and DataReaders is exchanged.

    Each element of this list must be a peer descriptor in the proper format (see NDDS_DISCOVERY_PEERS_format).

    [default] builtin.udpv4://239.255.0.1, builtin.udpv4://127.0.0.1, builtin.shmem:// (See also NDDS_DISCOVERY_PEERS)

    [range] Sequence of arbitrary length.


    See also: NDDS_DISCOVERY_PEERS_format
    See also: DDS.DomainParticipant.add_peer()

    Multicast_Receive_Addresses: Specifies the multicast group addresses on which discovery-related meta-traffic can be received by the DomainParticipant.

    The multicast group addresses on which the Discovery mechanism will listen for meta-traffic.

    Each element of this list must be a valid multicast address (IPv4 or IPv6) in the proper format (see NDDS_DISCOVERY_PEERS_address_format).

    The domain_id determines the multicast port on which the Discovery mechanism can receive meta-data.

    If NDDS_DISCOVERY_PEERS does not contain a multicast address, then the string sequence DDS.DiscoveryQosPolicy.multicast_receive_addresses is cleared and the RTI discovery process will not listen for discovery messages via multicast.

    If NDDS_DISCOVERY_PEERS contains one or more multicast addresses, the addresses will be stored in DDS.DiscoveryQosPolicy.multicast_receive_addresses, starting at element 0. They will be stored in the order they appear NDDS_DISCOVERY_PEERS.

    Note: Currently, RTI Connext will only listen for discovery traffic on the first multicast address (element 0) in DDS.DiscoveryQosPolicy.multicast_receive_addresses.

    [default] builtin.udpv4://239.255.0.1 (See also NDDS_DISCOVERY_PEERS)

    [range] Sequence of length [0,1], whose elements are multicast addresses. Currently only the first multicast address (if any) is used. The rest are ignored.


    See also: NDDS_DISCOVERY_PEERS_address_format

    Metatraffic_Transport_Priority: The transport priority to use for the Discovery meta-traffic.

    The discovery metatraffic will be sent by the built-in DDS.DataWriter using this transport priority.

    [default] 0

    Accept_Unknown_Peers: Whether to accept a new participant that is not in the initial peers list.

    If DDS.BOOLEAN_FALSE, the participant will only communicate with those in the initial peers list and those added via DDS.DomainParticipant.add_peer().

    If DDS.BOOLEAN_TRUE, the participant will also communicate with all discovered remote participants.

    Note: If accept_unknown_peers is DDS.BOOLEAN_FALSE and shared memory is disabled, applications on the same node will not communicate if only 'localhost' is specified in the peers list. If shared memory is disabled or 'shmem://' is not specified in the peers list, to communicate with other applications on the same node through the loopback interface, you must put the actual node address or hostname in NDDS_DISCOVERY_PEERS.

    [default] DDS.BOOLEAN_TRUE

    Enable_Endpoint_Discovery: Whether to automatically enable endpoint discovery for all the remote participants.

    If DDS.BOOLEAN_TRUE, endpoint discovery will automatically occur for every discovered remote participant.

    If DDS.BOOLEAN_FALSE, endpoint discovery will be initially disabled and manual activation is required for each discovered participant by calling DDS.DomainParticipant.resume_endpoint_discovery.

    [default] DDS.BOOLEAN_TRUE

    Discovery_ParticipantInformation

    type Discovery_ParticipantInformation is record
          Participant_Discovery_Id         : aliased Long := 0;
          Participant_Discovery_Version    : aliased Long := 0;
          Participant_Discovery_Vendor_Id  : aliased Long := 0;
          Participant_Discovery_Parameters : aliased Octet_Seq.Sequence;
       end record with
         Convention => C;

    Discovery_ParticipantInformation_Access

    type Discovery_ParticipantInformation_Access is access all Discovery_ParticipantInformation;

    Discovery_ParticipantInformation_Array

    type Discovery_ParticipantInformation_Array is array
         (Natural range <>) of aliased Discovery_ParticipantInformation;

    Discovery_EndpointInformation

    type Discovery_EndpointInformation is record
          Endpoint_Discovery_Id         : aliased Long := 0;
          Endpoint_Discovery_Version    : aliased Long := 0;
          Endpoint_Discovery_Vendor_Id  : aliased Long := 0;
          Endpoint_Discovery_Parameters : aliased Octet_Seq.Sequence;
       end record with
         Convention => C;

    Discovery_EndpointInformation_Access

    type Discovery_EndpointInformation_Access is access all Discovery_EndpointInformation;

    Discovery_EndpointInformation_Array

    type Discovery_EndpointInformation_Array is array
         (Natural range <>) of aliased Discovery_EndpointInformation;

    TransportBuiltinKind

    type TransportBuiltinKind is new Unsigned_Long;

    Summary: Built-in transport kind.


    See also: DDS.TransportBuiltinKindMask

    TransportBuiltinKindMask

    subtype TransportBuiltinKindMask is TransportBuiltinKind;

    TransportBuiltinQosPolicy

    type TransportBuiltinQosPolicy is record
          Mask : TransportBuiltinKindMask;
       end record with
         Convention => C;

    Summary: Specifies which built-in transports are used.

    Three different transport plug-ins are built into the core RTI Connext libraries (for most supported target platforms): UDPv4, shared memory, and UDPv6.

    This QoS policy allows you to control which of these built-in transport plug-ins are used by a DDS.DomainParticipant. By default, only the UDPv4 and shared memory plug-ins are enabled (although on some embedded platforms, the shared memory plug-in is not available). In some cases, users will disable the shared memory transport when they do not want applications to use shared memory to communicate when running on the same node.

    Note: If one application is configured to use UDPv4 and shared memory, while another application is only configured for UDPv4, and these two applications run on the same node, they will not communicate. This is due to an internal optimization which will default to use shared memory instead of loopback. However if the other peer application does not enable shared memory there is no common transport, therefore they will not communicate.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Mask: Specifies the built-in transports that are registered automatically when the DDS.DomainParticipant is enabled.

    RTI Connext provides several built-in transports. Only those that are specified with this mask are registered automatically when the DDS.DomainParticipant is enabled.

    [default] DDS_TRANSPORTBUILTIN_MASK_DEFAULT

    RtpsWellKnownPorts_T

    type RtpsWellKnownPorts_T is record
          Port_Base                     : aliased Long := 7400;
          Domain_Id_Gain                : aliased Long := 10;
          Participant_Id_Gain           : aliased Long := 1000;
          Builtin_Multicast_Port_Offset : aliased Long := 2;
          Builtin_Unicast_Port_Offset   : aliased Long := 0;
          User_Multicast_Port_Offset    : aliased Long := 1;
          User_Unicast_Port_Offset      : aliased Long := 3;
       end record with
         Convention => C;

    Summary: RTPS well-known port mapping configuration.

    RTI Connext uses the RTPS wire protocol. The discovery protocols defined by RTPS rely on well-known ports to initiate discovery. These well-known ports define the multicast and unicast ports on which a Participant will listen for discovery metatraffic from other Participants. The discovery metatraffic contains all the information required to establish the presence of remote DDS entities in the network.

    The well-known ports are defined by RTPS in terms of port mapping expressions with several tunable parameters, which allow you to customize what network ports are used by dds. These parameters are exposed in DDS.RtpsWellKnownPorts_t. In order for all Participants in a system to correctly discover each other, it is important that they all use the same port mapping expressions.

    The actual port mapping expressions, as defined by the RTPS specification, can be found below. In addition to the parameters listed in DDS.RtpsWellKnownPorts_t, the port numbers depend on:

    - domain_id, as specified in DDS.DomainParticipantFactory.create_participant

    - participant_id, as specified using DDS.WireProtocolQosPolicy.participant_id

    The domain_id parameter ensures no port conflicts exist between Participants belonging to different domains. This also means that discovery metatraffic in one domain is not visible to Participants in a different domain. The participant_id parameter ensures that unique unicast port numbers are assigned to Participants belonging to the same domain on a given host.

    The metatraffic_unicast_port is used to exchange discovery metatraffic using unicast.

    metatraffic_unicast_port = port_base + (domain_id_gain * domain_id) + (participant_id_gain * participant_id) + builtin_unicast_port_offset

    The metatraffic_multicast_port is used to exchange discovery metatraffic using multicast. The corresponding multicast group addresses are specified via DDS.DiscoveryQosPolicy.multicast_receive_addresses on a DDS.DomainParticipant entity.

    metatraffic_multicast_port = port_base + (domain_id_gain * domain_id) + builtin_multicast_port_offset

    RTPS also defines the default multicast and unicast ports on which DataReaders and DataWriters receive usertraffic. These default ports can be overridden using the DDS.DataReaderQos.multicast, DDS.DataReaderQos.unicast, or by the DDS.DataWriterQos.unicast QoS policies.

    The usertraffic_unicast_port is used to exchange user data using unicast.

    usertraffic_unicast_port = port_base + (domain_id_gain * domain_id) + (participant_id_gain * participant_id) + user_unicast_port_offset

    The usertraffic_multicast_port is used to exchange user data using multicast. The corresponding multicast group addresses can be configured using DDS.TransportMulticastQosPolicy.

    usertraffic_multicast_port = port_base + (domain_id_gain * domain_id) + user_multicast_port_offset

    By default, the port mapping parameters are configured to compliant with OMG's DDS Interoperability Wire Protocol (see also DDS.INTEROPERABLE_RTPS_WELL_KNOWN_PORTS).

    The OMG's DDS Interoperability Wire Protocol compliant port mapping parameters are not backwards compatible with previous versions of the RTI Connext middleware.

    When modifying the port mapping parameters, care must be taken to avoid port aliasing. This would result in undefined discovery behavior. The chosen parameter values will also determine the maximum possible number of domains in the system and the maximum number of participants per domain. Additionally, any resulting mapped port number must be within the range imposed by the underlying transport. For example, for UDPv4, this range typically equals [1024 - 65535].

    QoS:
    DDS.WireProtocolQosPolicy

    Port_Base: The base port offset.

    All mapped well-known ports are offset by this value.

    [default] 7400

    [range] [>= 1], but resulting ports must be within the range imposed by the underlying transport.

    Domain_Id_Gain: Tunable domain gain parameter.

    Multiplier of the domain_id. Together with participant_id_gain, it determines the highest domain_id and participant_id allowed on this network.

    In general, there are two ways to setup domain_id_gain and participant_id_gain parameters.

    If domain_id_gain > participant_id_gain, it results in a port mapping layout where all DDS.DomainParticipant instances within a single domain occupy a consecutive range of domain_id_gain ports. Precisely, all ports occupied by the domain fall within:

    (port_base + (domain_id_gain * domain_id))
    and:
    (port_base + (domain_id_gain * (domain_id + 1)) - 1)

    Under such a case, the highest domain_id is limited only by the underlying transport's maximum port. The highest participant_id, however, must satisfy:

    max_participant_id < (domain_id_gain / participant_id_gain)

    On the contrary, if domain_id_gain <= participant_id_gain, it results in a port mapping layout where a given domain's DDS.DomainParticipant instances occupy ports spanned across the entire valid port range allowed by the underlying transport. For instance, it results in the following potential mapping:

    Mapped Port Domain Id Participant ID
    higher port number Domain Id = 1 Participant ID = 2
    Domain Id = 0 Participant ID = 2
    Domain Id = 1 Participant ID = 1
    Domain Id = 0 Participant ID = 1
    Domain Id = 1 Participant ID = 0
    lower port number Domain Id = 0 Participant ID = 0

    Under this case, the highest participant_id is limited only by the underlying transport's maximum port. The highest domain_id, however, must satisfy:

    max_domain_id < (participant_id_gain / domain_id_gain)

    Additionally, domain_id_gain also determines the range of the port-specific offsets.

    domain_id_gain > abs(builtin_multicast_port_offset - user_multicast_port_offset)
    domain_id_gain > abs(builtin_unicast_port_offset - user_unicast_port_offset)

    Violating this may result in port aliasing and undefined discovery behavior.

    [default] 250

    [range] [> 0], but resulting ports must be within the range imposed by the underlying transport.

    Participant_Id_Gain: Tunable participant gain parameter.

    Multiplier of the participant_id. See DDS.RtpsWellKnownPorts_t.domain_id_gain for its implications on the highest domain_id and participant_id allowed on this network.

    Additionally, participant_id_gain also determines the range of builtin_unicast_port_offset and user_unicast_port_offset.

    participant_id_gain > abs(builtin_unicast_port_offset - user_unicast_port_offset)

    [default] 2

    [range] [> 0], but resulting ports must be within the range imposed by the underlying transport.

    Builtin_Multicast_Port_Offset: Additional offset for metatraffic multicast port.

    It must be unique from other port-specific offsets.

    [default] 0

    [range] [>= 0], but resulting ports must be within the range imposed by the underlying transport.

    Builtin_Unicast_Port_Offset: Additional offset for metatraffic unicast port.

    It must be unique from other port-specific offsets.

    [default] 10

    [range] [>= 0], but resulting ports must be within the range imposed by the underlying transport.

    User_Multicast_Port_Offset: Additional offset for usertraffic multicast port.

    It must be unique from other port-specific offsets.

    [default] 1

    [range] [>= 0], but resulting ports must be within the range imposed by the underlying transport.

    User_Unicast_Port_Offset: Additional offset for usertraffic unicast port.

    It must be unique from other port-specific offsets.

    [default] 11

    [range] [>= 0], but resulting ports must be within the range imposed by the underlying transport.

    RtpsReservedPortKind

    type RtpsReservedPortKind is new Unsigned_Long;

    Summary: RTPS reserved port kind, used to identify the types of ports that can be reserved on domain participant enable.


    See also: DDS.WireProtocolQosPolicy.rtps_reserved_port_mask

    RtpsReservedPortKindMask

    subtype RtpsReservedPortKindMask is RtpsReservedPortKind;

    WireProtocolQosPolicyAutoKind

    type WireProtocolQosPolicyAutoKind is new Unsigned_Long;

    Summary: Mechanism to automatically calculate the GUID prefix.


    See also: DDS.WireProtocolQosPolicy.rtps_auto_id_kind

    WireProtocolQosPolicy

    type WireProtocolQosPolicy is record
          Participant_Id          : aliased Long := -1;
          Rtps_Host_Id            : aliased Unsigned_Long := RTPS_AUTO_ID;
          Rtps_App_Id             : aliased Unsigned_Long := RTPS_AUTO_ID;
          Rtps_Instance_Id        : aliased Unsigned_Long := RTPS_AUTO_ID;
          Rtps_Well_Known_Ports   : aliased RtpsWellKnownPorts_T := RTPS_WELL_KNOWN_PORTS_DEFAULT;
          Rtps_Reserved_Port_Mask : aliased Long := 0;
          Rtps_Auto_Id_Kind       : aliased WireProtocolQosPolicyAutoKind := RTPS_AUTO_ID_FROM_IP;
          compute_crc             : aliased Boolean := False;
          check_crc               : aliased Boolean := False;
       end record with
         Convention => C;

    Summary: Specifies the wire-protocol-related attributes for the DDS.DomainParticipant.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    This QoS policy configures some participant-wide properties of the DDS Real-Time Publish Subscribe (RTPS) on-the-wire protocol. (DDS.DataWriterProtocolQosPolicy and DDS.DataReaderProtocolQosPolicy configure RTPS and reliability properties on a per DDS.DataWriter or DDS.DataReader basis.)

    NOTE: The default QoS policies returned by RTI Connext contain the correctly initialized wire protocol attributes. The defaults are not normally expected to be modified, but are available to the advanced user customizing the implementation behavior.

    The default values should not be modified without an understanding of the underlying Real-Time Publish Subscribe (RTPS) wire protocol.

    In order for the discovery process to work correctly, each DDS.DomainParticipant must have a unique identifier. This QoS policy specifies how that identifier should be generated.

    RTPS defines a 96-bit prefix to this identifier; each DDS.DomainParticipant must have a unique value for this prefix relative to all other participants in its domain. To make it easier to control how this 96-bit value is generated, RTI Connext divides it into three integers: a host ID, the value of which is based on the identity of the identity of the machine on which the participant is executing; an application ID, the value of which is based on the process or task in which the particpant is contained; and an instance ID, which identifies the participant itself.

    This QoS policy provides you with a choice of algorithms for generating these values automatically. In case none of these algorithms suit your needs, you may also choose to specify some or all of them yourself.

    The following three fields:

    • DDS.WireProtocolQosPolicy.rtps_host_id
    • DDS.WireProtocolQosPolicy.rtps_app_id
    • DDS.WireProtocolQosPolicy.rtps_instance_id
    comprise the GUID prefix and by default are set to DDS_RTPS_AUTO_ID. The meaning of this flag depends on the value assigned to the DDS.WireProtocolQosPolicy.rtps_auto_id_kind field.

    Depending on the DDS.WireProtocolQosPolicy.rtps_auto_id_kind value, there are two different scenarios:

    1. In the default and most common scenario, DDS.WireProtocolQosPolicy.rtps_auto_id_kind is set to DDS.RTPS_AUTO_ID_FROM_IP. Doing so, each field is interpreted as follows:
      • rtps_host_id: The 32-bit value of the IPv4 of the first up and running interface of the host machine is assigned.
      • rtps_app_id: The process (or task) ID is assigned.
      • rtps_instance_id: A counter is assigned that is incremented per new participant.

      NOTE: If the IP assigned to the interface is not unique within the network (for instance, if it is not configured), it is possible that the GUID (specifically, the rtps_host_id portion) may also not be unique.

    2. In this situation, RTI Connext provides a different value for rtps_auto_id_kind: DDS.RTPS_AUTO_ID_FROM_MAC. As the name suggests, this alternative mechanism uses the MAC address instead of the IPv4 address. Since the MAC address size is up to 64 bits, the logical mapping of the host information, the application ID, and the instance identifiers has to change.

      Note to Solaris Users: To use DDS.RTPS_AUTO_ID_FROM_MAC, you must run the RTI Connext application while logged in as root.


      Using DDS.RTPS_AUTO_ID_FROM_MAC, the default value of each field is interpreted as follows:

      • rtps_host_id: The first 32 bits of the MAC address of the first up and running interface of the host machine are assigned.
      • rtps_app_id: The last 32 bits of the MAC address of the first up and running interface of the host machine are assigned.
      • rtps_instance_id: This field is split into two different parts. The process (or task) ID is assigned to the first 24 bits. A counter is assigned to the last 8 bits. This counter is incremented per new participant.
      • In both scenarios, you can change the value of each field independently.

      If DDS.RTPS_AUTO_ID_FROM_MAC is used, the rtps_instance_id has been logically split into two parts: 24 bits for the process/task ID and 8 bits for the per new participant counter. To give to users the ability to manually set the two parts independently, a bit-field mechanism has been introduced for the rtps_instance_id field when it is used in combination with DDS.RTPS_AUTO_ID_FROM_MAC. If one of the two parts is set to 0, only this part will be handled by RTI Connext and you will be able to handle the other one manually.

    Some examples are provided to clarify the behavior of this QoSPolicy in case you want to change the default behavior with DDS.RTPS_AUTO_ID_FROM_MAC.

    First, get the participant QoS from the DomainParticipantFactory:

    DomainParticipantFactory.TheParticipantFactory.
                     get_default_participant_qos(participant_qos); 

    Second, change the DDS.WireProtocolQosPolicy using one of the options shown below.

    Third, create the DDS.DomainParticipant as usual, using the modified QoS structure instead of the default one.

    Option 1: Use DDS.RTPS_AUTO_ID_FROM_MAC to explicitly set just the application/task identifier portion of the rtps_instance_id field.

    participant_qos.wire_protocol.rtps_auto_id_kind = 
                     WireProtocolQosPolicyAutoKind.RTPS_AUTO_ID_FROM_MAC; 
     participant_qos.wire_protocol.rtps_host_id      = 
                     WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_app_id       = 
                     WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_instance_id  = (/* App ID */ (12 << 8) | 
                                                        /* Instance ID*/ (WireProtocolQosPolicy.RTPS_AUTO_ID));  
    

    Option 2: Handle only the per participant counter and let RTI Connext handle the application/task identifier:

    participant_qos.wire_protocol.rtps_auto_id_kind =
                             WireProtocolQosPolicyAutoKind.RTPS_AUTO_ID_FROM_MAC; 
     participant_qos.wire_protocol.rtps_host_id      = WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_app_id       = WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_instance_id  =  (/* App ID */ (WireProtocolQosPolicy.RTPS_AUTO_ID) | 
                                                        /* Instance ID*/ (12));           
    

    Option 3: Handle the entire rtps_instance_id field yourself:

    participant_qos.wire_protocol.rtps_auto_id_kind = WireProtocolQosPolicyAutoKind.RTPS_AUTO_ID_FROM_MAC; 
     participant_qos.wire_protocol.rtps_host_id      = WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_app_id       = WireProtocolQosPolicy.RTPS_AUTO_ID;          
     participant_qos.wire_protocol.rtps_instance_id  = ( /* App ID */ (12 << 8)) |
                                                         /* Instance ID */ (9) ) 
    

    NOTE: If you are using DDS.RTPS_AUTO_ID_FROM_MAC as rtps_auto_id_kind and you decide to manually handle the rtps_instance_id field, you must ensure that both parts are non-zero (otherwise RTI Connext will take responsibility for them). RTI recommends that you always specify the two parts separately in order to avoid errors.

    Option 4: Let RTI Connext handle the entire rtps_instance_id field:

    participant_qos.wire_protocol.rtps_auto_id_kind = 
                     WireProtocolQosPolicyAutoKind.RTPS_AUTO_ID_FROM_MAC; 
     participant_qos.wire_protocol.rtps_host_id      = WireProtocolQosPolicy.RTPS_AUTO_ID;
     participant_qos.wire_protocol.rtps_app_id       = WireProtocolQosPolicy.RTPS_AUTO_ID; 
     participant_qos.wire_protocol.rtps_instance_id  = WireProtocolQosPolicy.RTPS_AUTO_ID;
    

    NOTE: If you are using DDS.RTPS_AUTO_ID_FROM_MAC as rtps_auto_id_kind and you decide to manually handle the rtps_instance_id field, you must ensure that both parts are non-zero (otherwise RTI Connext will take responsibility for them). RTI recommends that you always specify the two parts separately in order to clearly show the difference.

    Participant_Id: A value used to distinguish among different participants belonging to the same domain on the same host.

    Determines the unicast port on which meta-traffic is received. Also defines the default unicast port for receiving user-traffic for DataReaders and DataWriters (can be overridden by the DDS.DataReaderQos.unicast or DDS.DataWriterQos.unicast).

    For more information on port mapping, please refer to DDS.RtpsWellKnownPorts_t.

    Each DDS.DomainParticipant in the same domain and running on the same host, must have a unique participant_id. The participants may be in the same address space or in distinct address spaces.

    A negative number (-1) means that RTI Connext will automatically resolve the participant ID as follows.

  • RTI Connext will pick the smallest participant ID based on the unicast ports available on the transports enabled for discovery.

  • RTI Connext will attempt to resolve an automatic port index either when a DomainPartcipant is enabled, or when a DataReader or DataWriter is created. Therefore, all the transports enabled for discovery must have been registered by this time. Otherwise, the discovery transports registered after resolving the automatic port index may produce port conflicts when the DomainPartcipant is enabled.

    [default] -1 [automatic], i.e. RTI Connext will automatically pick the participant_id, as described above.

    [range] [>= 0], or -1, and does not violate guidelines stated in DDS.RtpsWellKnownPorts_t.


    See also: DDS.Entity.enable()

    Rtps_Host_Id: The RTPS Host ID of the domain participant.

    A machine/operating system specific host ID that is unique in the domain.

    [default] DDS_RTPS_AUTO_ID. The default value is interpreted as follows:
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_IP (the default value), the value will be interpreted as the IPv4 address of the first up and running interface of the host machine.
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_MAC, the value will be interpreted as the first 32 bits of the MAC address assigned to the first up and running interface of the host machine.

    [range] [0,0xffffffff]

    Rtps_App_Id: The RTPS App ID of the domain participant.

    A participant specific ID that, together with the rtps_instance_id, is unique within the scope of the rtps_host_id.

    If a participant dies and is restarted, it is recommended that it be given an app ID that is distinct from the previous one so that other participants in the domain can distinguish between them.

    [default] DDS_RTPS_AUTO_ID. The default value is interpreted as follows:
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_IP (default value for this field) the value will be the process (or task) ID.
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_MAC the value will be the last 32 bits of the MAC address assigned to the first up and running interface of the host machine. [range] [0,0xffffffff]

    Rtps_Instance_Id: The RTPS Instance ID of the DDS.DomainParticipant.

    This is an instance-specific ID of a participant that, together with the rtps_app_id, is unique within the scope of the rtps_host_id.

    If a participant dies and is restarted, it is recommended that it be given an instance ID that is distinct from the previous one so that other participants in the domain can distinguish between them.

    [default] DDS_RTPS_AUTO_ID. The default value is interpreted as follows:
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_IP (the default value), a counter is assigned that is incremented per new participant. For VxWorks-653, the first 8 bits are assigned to the partition id for the application.
    If DDS.WireProtocolQosPolicy.rtps_auto_id_kind is equal to DDS.RTPS_AUTO_ID_FROM_MAC, the first 24 bits are assigned to the application/task identifier and the last 8 bits are assigned to a counter that is incremented per new paricipant.

    [range] [0,0xffffffff] NOTE: If you use DDS.RTPS_AUTO_ID_FROM_MAC as rtps_auto_id_kind and you decide to manually handle the rtps_instance_id field, you must ensure that both the two parts are non-zero, otherwise the middleware will take responsibility for them. We recommend that you always specify the two parts separately in order to avoid errors. (examples)

    Rtps_Well_Known_Ports: Configures the RTPS well-known port mappings.

    Determines the well-known multicast and unicast port mappings for discovery (meta) traffic and user traffic.

    [default] DDS.INTEROPERABLE_RTPS_WELL_KNOWN_PORTS

    rtps_reserved_port_mask: Specifies which well-known ports to reserve when enabling the participant.

    Specifies which of the well-known multicast and unicast ports will be reserved when the DomainParticipant is enabled. Failure to allocate a port that is computed based on the DDS.RtpsWellKnownPorts_t will be detected at this time, and the enable operation will fail.

    [default] DDS.RTPS_RESERVED_PORT_MASK_DEFAULT

    rtps_auto_id_kind: Kind of auto mechanism used to calculate the GUID prefix.

    [default] DDS.RTPS_AUTO_ID_FROM_IP

  • Locator_Address_Array_T

    type Locator_Address_Array_T is array (0 .. LOCATOR_ADDRESS_LENGTH_MAX - 1) of Octet;

    Locator_T

    type Locator_T is record
          Kind           : aliased Long := 0;
          Port           : aliased Unsigned_Long := 0;
          Address        : aliased Locator_Address_Array_T := (others => 0);
          Encapsulations : aliased EncapsulationId_Seq.Sequence;
       end record with
         Convention => C;

    Summary: <<ext>> Type used to represent the addressing information needed to send a message to an RTPS Endpoint using one of the supported transports.

    Kind: The kind of locator.

    If the Locator_t kind is DDS_LOCATOR_KIND_UDPv4, the address contains an IPv4 address. In this case, the leading 12 octets of the DDS.Locator_t.address must be zero. The last 4 octets of DDS.Locator_t.address are used to store the IPv4 address.

    If the Locator_t kind is DDS_LOCATOR_KIND_UDPv6, the address contains an IPv6 address. IPv6 addresses typically use a shorthand hexadecimal notation that maps one-to-one to the 16 octets in the DDS.Locator_t.address field.

    Port: the port number

    Address: A DDS_LOCATOR_ADDRESS_LENGTH_MAX octet field to hold the IP address.

    Locator_T_Access

    type Locator_T_Access is access all Locator_T;

    Locator_T_Array

    type Locator_T_Array is array (Natural range <>) of aliased Locator_T;

    ProtocolVersion_T

    type ProtocolVersion_T  is record
          Major : aliased Octet := 0;
          Minor : aliased Octet := 0;
       end record with
         Convention => C;

    Summary: <<ext>> Type used to represent the version of the RTPS protocol.

    Major: Major protocol version number

    Minor: Minor protocol version number

    VendorId_Array_T

    type VendorId_Array_T is array (0 .. VENDOR_ID_LENGTH_MAX - 1) of Octet;

    VendorId_T

    type VendorId_T is record
          VendorId : aliased VendorId_Array_T := (others => 0);
       end record with
         Convention => C;

    Summary: <<ext>> Type used to represent the vendor of the service implementing the RTPS protocol.

    VendorId: The vendor Id.

    ProductVersion_T

    type ProductVersion_T is record
          Major    : aliased Char := Char (ASCII.NUL);
          Minor    : aliased Char := Char (ASCII.NUL);
          Release  : aliased Char := '0';
          Revision : aliased Char := Char (ASCII.NUL);
       end record with
         Convention => C;

    Summary: <<ext>> Type used to represent the current version of dds.

    Major: Major product version.

    Minor: Minor product version.

    Release: Release letter for product version.

    Revision: Revision number of product.

    DataReaderResourceLimitsQosPolicy

    type DataReaderResourceLimitsQosPolicy is record
          Max_Remote_Writers                          : aliased Long := -1;
          Max_Remote_Writers_Per_Instance             : aliased Long := -1;
          Max_Samples_Per_Remote_Writer               : aliased Long := -1;
          Max_Infos                                   : aliased Long := -1;
          Initial_Remote_Writers                      : aliased Long := 2;
          Initial_Remote_Writers_Per_Instance         : aliased Long := 2;
          Initial_Infos                               : aliased Long := 32;
          Initial_Outstanding_Reads                   : aliased Long := 2;
          Max_Outstanding_Reads                       : aliased Long := -1;
          Max_Samples_Per_Read                        : aliased Long := 1024;
          Disable_Fragmentation_Support               : aliased DDS.Boolean := False;
          Max_Fragmented_Samples                      : aliased Long := 1024;
          Initial_Fragmented_Samples                  : aliased Long := 4;
          Max_Fragmented_Samples_Per_Remote_Writer    : aliased Long := 256;
          Max_Fragments_Per_Sample                    : aliased Long := 512;
          Dynamically_Allocate_Fragmented_Samples     : aliased DDS.Boolean := False;
          Max_Total_Instances                         : aliased Long := 32;
          Max_Remote_Virtual_Writers                  : aliased Long := -1;
          Initial_Remote_Virtual_Writers              : aliased Long := 2;
          Max_Remote_Virtual_Writers_Per_Instance     : aliased Long := -1;
          Initial_Remote_Virtual_Writers_Per_Instance : aliased Long := 2;
          Max_Remote_Writers_Per_Sample               : aliased Long := 3;
          Max_Query_Condition_Filters                 : aliased Long := 4;
          Max_App_Ack_Response_Length                 : aliased Long := 0;
          Keep_Minimum_State_For_Instances            : aliased DDS.Boolean := True;
          Initial_Topic_Queries                       : aliased Long := 1;
          Max_Topic_Queries                           : aliased Long := -1;
       end record with
         Convention => C;

    Summary: Various settings that configure how a DDS.DataReader allocates and uses physical memory for internal resources.

    DataReaders must allocate internal structures to handle the maximum number of DataWriters that may connect to it, whether or not a DDS.DataReader handles data fragmentation and how many data fragments that it may handle (for data samples larger than the MTU of the underlying network transport), how many simultaneous outstanding loans of internal memory holding data samples can be provided to user code, as well as others.

    Most of these internal structures start at an initial size and, by default, will grow as needed by dynamically allocating additional memory. You may set fixed, maximum sizes for these internal structures if you want to bound the amount of memory that can be used by a DDS.DataReader. By setting the initial size to the maximum size, you will prevent RTI Connext from dynamically allocating any memory after the creation of the DDS.DataReader.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Max_Remote_Writers: The maximum number of remote writers from which a DDS.DataReader may read, including all instances.

    [default] DDS.LENGTH_UNLIMITED
    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_remote_writers, >= max_remote_writers_per_instance

    For unkeyed types, this value has to be equal to max_remote_writers_per_instance if max_remote_writers_per_instance is not equal to DDS.LENGTH_UNLIMITED.

    Note: For efficiency, set max_remote_writers >= DDS.DataReaderResourceLimitsQosPolicy.max_remote_writers_per_instance.

    Max_Remote_Writers_Per_Instance: The maximum number of remote writers from which a DDS.DataReader may read a single instance.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1024] or DDS.LENGTH_UNLIMITED, <= max_remote_writers or DDS.LENGTH_UNLIMITED, >= initial_remote_writers_per_instance

    For unkeyed types, this value has to be equal to max_remote_writers if it is not DDS.LENGTH_UNLIMITED.

    Note: For efficiency, set max_remote_writers_per_instance <= DDS.DataReaderResourceLimitsQosPolicy.max_remote_writers

    Max_Samples_Per_Remote_Writer: The maximum number of out-of-order samples from a given remote DDS.DataWriter that a DDS.DataReader may store when maintaining a reliable connection to the DDS.DataWriter.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 100 million] or DDS.LENGTH_UNLIMITED, <= DDS.ResourceLimitsQosPolicy.max_samples

    Max_Infos: The maximum number of info units that a DDS.DataReader can use to store DDS.SampleInfo.

    When read/take is called on a DataReader, the DataReader passes a sequence of data samples and an associated sample info sequence. The sample info sequence contains additional information for each data sample.

    max_infos determines the resources allocated for storing sample info. This memory is loaned to the application when passing a sample info sequence.

    Note that sample info is a snapshot, generated when read/take is called.

    max_infos should not be less than max_samples.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_infos

    Initial_Remote_Writers: The initial number of remote writers from which a DDS.DataReader may read, including all instances.

    [default] 2

    [range] [1, 1 million], <= max_remote_writers

    For unkeyed types this value has to be equal to initial_remote_writers_per_instance.

    Note: For efficiency, set initial_remote_writers >= DDS.DataReaderResourceLimitsQosPolicy.initial_remote_writers_per_instance.

    Initial_Remote_Writers_Per_Instance: The initial number of remote writers from which a DDS.DataReader may read a single instance.

    [default] 2

    [range] [1,1024], <= max_remote_writers_per_instance

    For unkeyed types this value has to be equal to initial_remote_writers.

    Note: For efficiency, set initial_remote_writers_per_instance <= DDS.DataReaderResourceLimitsQosPolicy.initial_remote_writers.

    Initial_Infos: The initial number of info units that a DDS.DataReader can have, which are used to store DDS.SampleInfo.

    [default] 32

    [range] [1,1 million], <= max_infos

    Initial_Outstanding_Reads: The initial number of outstanding calls to read/take (or one of their variants) on the same DDS.DataReader for which memory has not been returned by calling FooDataReader.return_loan.

    [default] 2

    [range] [1, 65536], <= max_outstanding_reads

    Max_Outstanding_Reads: The maximum number of outstanding read/take calls (or one of their variants) on the same DDS.DataReader for which memory has not been returned by calling FooDataReader.return_loan.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 65536] or DDS.LENGTH_UNLIMITED, >= initial_outstanding_reads

    Max_Samples_Per_Read: The maximum number of data samples that the application can receive from the middleware in a single call to FooDataReader.read or FooDataReader.take. If more data exists in the middleware, the application will need to issue multiple read/take calls.

    When reading data using listeners, the expected number of samples available for delivery in a single take call is typically small: usually just one, in the case of unbatched data, or the number of samples in a single batch, in the case of batched data. (See DDS.BatchQosPolicy for more information about this feature.) When polling for data or using a DDS.WaitSet, however, multiple samples (or batches) could be retrieved at once, depending on the data rate.

    A larger value for this parameter makes the API simpler to use at the expense of some additional memory consumption.

    [default] 1024

    [range] [1,65536]

    Disable_Fragmentation_Support: Determines whether the DDS.DataReader can receive fragmented samples.

    When fragmentation support is not needed, disabling fragmentation support will save some memory resources.

    [default] DDS.BOOLEAN_FALSE

    Max_Fragmented_Samples: The maximum number of samples for which the DDS.DataReader may store fragments at a given point in time.

    At any given time, a DDS.DataReader may store fragments for up to max_fragmented_samples samples while waiting for the remaining fragments. These samples need not have consecutive sequence numbers and may have been sent by different DDS.DataWriter instances.

    Once all fragments of a sample have been received, the sample is treated as a regular sample and becomes subject to standard QoS settings such as DDS.ResourceLimitsQosPolicy.max_samples.

    The middleware will drop fragments if the max_fragmented_samples limit has been reached. For best-effort communication, the middleware will accept a fragment for a new sample, but drop the oldest fragmented sample from the same remote writer. For reliable communication, the middleware will drop fragments for any new samples until all fragments for at least one older sample from that writer have been received.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 1024

    [range] [1, 1 million]

    Initial_Fragmented_Samples: The initial number of samples for which a DDS.DataReader may store fragments.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 4

    [range] [1,1024], <= max_fragmented_samples

    Max_Fragmented_Samples_Per_Remote_Writer: The maximum number of samples per remote writer for which a DDS.DataReader may store fragments.

    Logical limit so a single remote writer cannot consume all available resources.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 256

    [range] [1, 1 million], <= max_fragmented_samples

    Max_Fragments_Per_Samples: Maximum number of fragments for a single sample.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED

    Dynamically_Allocate_Fragmented_Samples: Determines whether the DDS.DataReader pre-allocates storage for storing fragmented samples.

    By default, the middleware does not allocate memory upfront, but instead allocates memory from the heap upon receiving the first fragment of a new sample. The amount of memory allocated equals the amount of memory needed to store all fragments in the sample. Once all fragments of a sample have been received, the sample is deserialized and stored in the regular receive queue. At that time, the dynamically allocated memory is freed again.

    This QoS setting is useful for large, but variable-sized data types where upfront memory allocation for multiple samples based on the maximum possible sample size may be expensive. The main disadvantage of not pre-allocating memory is that one can no longer guarantee the middleware will have sufficient resources at run-time.

    If dynamically_allocate_fragmented_samples is set to DDS.BOOLEAN_FALSE, the middleware will allocate memory upfront for storing fragments for up to DDS.DataReaderResourceLimitsQosPolicy.initial_fragmented_samples samples. This memory may grow up to DDS.DataReaderResourceLimitsQosPolicy.max_fragmented_samples if needed.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] DDS.BOOLEAN_TRUE

    Max_Total_Instances: Maximum number of instances for which a DataReader will keep state.

    The maximum number of instances actively managed by a DataReader is determined by DDS.ResourceLimitsQosPolicy.max_instances.

    These instances have associated DataWriters or samples in the DataReader's queue and are visible to the user through operations such as FooDataReader.take, FooDataReader.read, and FooDataReader.get_key_value.

    The features Durable Reader State, MultiChannel DataWriters and RTI Persistence Service require RTI Connext to keep some internal state even for instances without DataWriters or samples in the DataReader's queue. The additional state is used to filter duplicate samples that could be coming from different DataWriter channels or from multiple executions of RTI Persistence Service.

    The total maximum number of instances that will be managed by the middleware, including instances without associated DataWriters or samples, is determined by max_total_instances.

    When a new instance is received, RTI Connext will check the resource limit DDS.ResourceLimitsQosPolicy.max_instances. If the limit is exceeded, RTI Connext will drop the sample and report it as lost and rejected. If the limit is not exceeded, RTI Connext will check max_total_instances. If max_total_instances is exceeded, RTI Connext will replace an existing instance without DataWriters and samples with the new one. The application could receive duplicate samples for the replaced instance if it becomes alive again.

    [default] DDS.AUTO_MAX_TOTAL_INSTANCES

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED or DDS.AUTO_MAX_TOTAL_INSTANCES, >= DDS.ResourceLimitsQosPolicy.max_instances

    Max_Remote_Virtual_Writers: The maximum number of remote virtual writers from which a DDS.DataReader may read, including all instances.

    When DDS.PresentationQosPolicy.access_scope is set to DDS.GROUP_PRESENTATION_QOS, this value determines the maximum number of DataWriter groups that can be managed by the DDS.Subscriber containing this DDS.DataReader.

    Since the DDS.Subscriber may contain more than one DDS.DataReader, only the setting of the first applies.

    [default] DDS.LENGTH_UNLIMITED
    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_remote_virtual_writers, >= max_remote_virtual_writers_per_instance

    Initial_Remote_Virtual_Writers: The initial number of remote virtual writers from which a DDS.DataReader may read, including all instances.

    [default] 2
    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, <= max_remote_virtual_writers

    Max_Remote_Virtual_Writers_Per_Instance: The maximum number of virtual remote writers that can be associated with an instance.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1024] or DDS.LENGTH_UNLIMITED, >= initial_remote_virtual_writers_per_instance

    For unkeyed types, this value is ignored.

    The features of Durable Reader State and MultiChannel DataWriters, and RTI Persistence Service require RTI Connext to keep some internal state per virtual writer and instance that is used to filter duplicate samples. These duplicate samples could be coming from different DataWriter channels or from multiple executions of RTI Persistence Service.

    Once an association between a remote virtual writer and an instance is established, it is permanent -- it will not disappear even if the physical writer incarnating the virtual writer is destroyed.

    If max_remote_virtual_writers_per_instance is exceeded for an instance, RTI Connext will not associate this instance with new virtual writers. Duplicates samples from these virtual writers will not be filtered on the reader.

    If you are not using Durable Reader State, MultiChannel DataWriters or RTI Persistence Service in your system, you can set this property to 1 to optimize resources.

    Initial_Remote_Virtual_Writers_Per_Instance: The initial number of virtual remote writers per instance.

    [default] 2

    [range] [1, 1024], <= max_remote_virtual_writers_per_instance

    For unkeyed types, this value is ignored.

    Max_Remote_Writers_Per_Sample: The maximum number of remote writers allowed to write the same sample.

    One scenario in which two DataWriters may write the same sample is Persistence Service. The DataReader may receive the same sample coming from the original DataWriter and from a Persistence Service DataWriter. [default] 3

    [range] [1, 1024]

    Max_Query_Condition_Filters: The maximum number of query condition filters a reader is allowed.

    [default] 4

    [range] [0, 32]

    This value determines the maximum number of unique query condition content filters that a reader may create.

    Each query condition content filter is comprised of both its query_expression and query_parameters. Two query conditions that have the same query_expression will require unique query condition filters if their query_paramters differ. Query conditions that differ only in their state masks will share the same query condition filter.

    Max_App_Ack_Response_Length: Maximum length of application-level acknowledgment response data

    The maximum length of response data in an application-level acknowledgment.

    When set to zero, no response data is sent with application-level acknowledgments.

    [default] 0

    [range] [0, 65536]

    Keep_Minimum_State_For_Instances: Whether or not keep a minimum instance state for up to DDS.DataReaderResourceLimitsQosPolicy.max_total_instances.

    The features Durable Reader State, multi-channel DataWriters, and Persistence Service require RTI Connext to keep some minimal internal state even for instances without DataWriters or DDS samples in the DataReader's queue, or that have been purged due to a dispose. The additional state is used to filter duplicate DDS samples that could be coming from different DataWriter channels or from multiple executions of Persistence Service. The total maximum number of instances that will be managed by the middleware, including instances without associated DataWriters or DDS samples or that have been purged due to a dispose, is determined by DDS.DataReaderResourceLimitsQosPolicy.max_total_instances.

    This additional state will only be kept for up to max_total_instances if this field is set to DDS.BOOLEAN_TRUE, otherwise the additional state will not be kept for any instances.

    [default] DDS.BOOLEAN_TRUE

    DataWriterResourceLimitsInstanceReplacementKind

    type DataWriterResourceLimitsInstanceReplacementKind is new Unsigned_Long;

    Summary: Sets the kinds of instances that can be replaced when instance resource limits are reached

    When DDS.ResourceLimitsQosPolicy.max_instances is reached, a DDS.DataWriter will try to make room for a new instance by attempting to reclaim an existing instance based on the instance replacement kind specified by DDS.DataWriterResourceLimitsQosPolicy.instance_replacement.

    Only instances whose states match the specified kinds are eligible to be replaced. In addition, an instance must have had all of its samples fully acknowledged for it to be considered replaceable.

    For all kinds, a DDS.DataWriter will replace the oldest instance satisfying that kind. For example, when the kind is DDS.UNREGISTERED_INSTANCE_REPLACEMENT, a DDS.DataWriter will remove the oldest, fully acknowledged, unregistered instance, if such an instance exists.

    If no replaceable instance exists, the invoked function will either return with an appropriate out-of-resources return code, or in the case of a write, it may first block to wait for an instance to be acknowledged. Otherwise, the DDS.DataWriter will replace the old instance with the new instance, and invoke, if available, the DDS.DataWriterListener.on_instance_replaced to notify the user about an instance being replaced.

    A DDS.DataWriter checks for replaceable instances in the following order, stopping once a replaceable instance is found:

    If DDS.DataWriterResourceLimitsQosPolicy.replace_empty_instances is DDS.BOOLEAN_TRUE, a DDS.DataWriter first tries replacing instances that have no samples. These empty instances can be unregistered, disposed, or alive. Next, a DDS.DataWriter tries replacing unregistered instances. Since an unregistered instance indicates that the DDS.DataWriter is done modifying it, unregistered instances are replaced before instances of any other state (alive, disposed). This is the same as the DDS.UNREGISTERED_INSTANCE_REPLACEMENT kind. Then, a DDS.DataWriter tries replacing what is specified by DDS.DataWriterResourceLimitsQosPolicy.instance_replacement. With unregistered instances already checked, this leaves alive and disposed instances. When both alive and disposed instances may be replaced, the kind specifies whether the particular order matters (e.g., DISPOSED_THEN_ALIVE, ALIVE_THEN_DISPOSED) or not (ALIVE_OR_DISPOSED).

    QoS:
    DDS.DataWriterResourceLimitsQosPolicy

    DataWriterResourceLimitsQosPolicy

    type DataWriterResourceLimitsQosPolicy is record
          Initial_Concurrent_Blocking_Threads : aliased DDS.Long := 1;
          Max_Concurrent_Blocking_Threads     : aliased DDS.Long := -1;
          Max_Remote_Reader_Filters           : aliased DDS.Long := 32;
          Initial_Batches                     : aliased DDS.Long := 8;
          Max_Batches                         : aliased DDS.Long := -1;
          Cookie_Max_Length                   : aliased DDS.Long := -1;
          Instance_Replacement                : aliased DataWriterResourceLimitsInstanceReplacementKind := UNREGISTERED_INSTANCE_REPLACEMENT;
          Replace_Empty_Instances             : aliased DDS.Boolean := False;
          Autoregister_Instances              : aliased DDS.Boolean := False;
          Initial_Virtual_Writers             : aliased DDS.Long :=  1;
          Max_Virtual_Writers                 : aliased DDS.Long := -1;
          Max_Remote_Readers                  : aliased DDS.Long := -1;
          Max_App_Ack_Remote_Readers          : aliased DDS.Long := -1;
          Initial_Active_Topic_Queries        : aliased DDS.Long :=  1;
          Max_Topic_Queries                   : aliased DDS.Long := -1;
       end record with Convention => C;

    Summary: Various settings that configure how a DDS.DataWriter allocates and uses physical memory for internal resources.

    DataWriters must allocate internal structures to handle the simultaneously blocking of threads trying to call FooDataWriter.write on the same DDS.DataWriter, for the storage used to batch small samples, and for content-based filters specified by DataReaders.

    Most of these internal structures start at an initial size and, by default, will be grown as needed by dynamically allocating additional memory. You may set fixed, maximum sizes for these internal structures if you want to bound the amount of memory that can be used by a DDS.DataWriter. By setting the initial size to the maximum size, you will prevent RTI Connext from dynamically allocating any memory after the creation of the DDS.DataWriter.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Initial_Concurrent_Blocking_Threads: The initial number of threads that are allowed to concurrently block on write call on the same DDS.DataWriter.

    This value only applies if DDS.HistoryQosPolicy has its kind set to DDS.KEEP_ALL_HISTORY_QOS and DDS.ReliabilityQosPolicy.max_blocking_time is > 0.

    [default] 1

    [range] [1, 10000], <= max_concurrent_blocking_threads

    Max_Concurrent_Blocking_Threads: The maximum number of threads that are allowed to concurrently block on write call on the same DDS.DataWriter.

    This value only applies if DDS.HistoryQosPolicy has its kind set to DDS.KEEP_ALL_HISTORY_QOS and DDS.ReliabilityQosPolicy.max_blocking_time is > 0.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 10000] or DDS.LENGTH_UNLIMITED, >= initial_concurrent_blocking_threads

    Max_Remote_Reader_Filters: The maximum number of remote DataReaders for which the DDS.DataWriter will perform content-based filtering.

    [default] DDS.LENGTH_UNLIMITED

    [range] [0, (2^31)-2] or DDS.LENGTH_UNLIMITED.

    0: The DDS.DataWriter will not perform filtering for any DDS.DataReader.

    1 to (2^31)-2: The DataWriter will filter for up to the specified number of DataReaders. In addition, the Datawriter will store the result of the filtering per sample per DataReader.

    DDS.LENGTH_UNLIMITED: The DataWriter will filter for up to (2^31)-2 DataReaders. However, in this case, the DataWriter will not store the filtering result per sample per DataReader. Thus, if a sample is resent (such as due to a loss of reliable communication), the sample will be filtered again.

    Initial_Batches: Represents the initial number of batches a DDS.DataWriter will manage.

    [default] 8

    [range] [1,100 million]


    See also: DDS.BatchQosPolicy

    Max_Batches: Represents the maximum number of batches a DDS.DataWriter will manage.

    [default] DDS.LENGTH_UNLIMITED

    When batching is enabled, the maximum number of samples that a DDS.DataWriter can store is limited by this value and DDS.ResourceLimitsQosPolicy.max_samples.

    [range] [1,100 million] or DDS.LENGTH_UNLIMITED >= DDS_RtpsReliableWriterProtocol_t::heartbeats_per_max_samples if batching is enabled


    See also: DDS.BatchQosPolicy

    Cookie_Max_Length: Represents the maximum length in bytes of a DDS.Cookie_t

    [default] DDS.LENGTH_UNLIMITED

    Sets the maximum allowed byte-sequence length of a DDS.Cookie_t used when writing with parameters

    [range] [1,100 million] or DDS.LENGTH_UNLIMITED


    See also: FooDataWriter.write_w_params, FooDataWriter.dispose_w_params, FooDataWriter.register_instance_w_params, FooDataWriter.unregister_instance_w_params

    Instance_Replacement: Sets the kinds of instances allowed to be replaced when instance resource limits are reached.

    When a DDS.DataWriter's number of active instances is greater than DDS.ResourceLimitsQosPolicy.max_instances, it will try to make room by replacing an existing instance. This field specifies the kinds of instances allowed to be replaced.

    If a replaceable instance is not available, either an out-of-resources exception will be returned, or the writer may block if the instance reclamation was done when writing.

    [default] DDS.UNREGISTERED_INSTANCE_REPLACEMENT


    See also: DDS.DataWriterResourceLimitsInstanceReplacementKind

    Replace_Empty_Instances: Whether or not to replace empty instances during instance replacement

    When a DDS.DataWriter has more active instances than allowed by DDS.ResourceLimitsQosPolicy.max_instances, it tries to make room by replacing an existing instance. This field configures whether empty instances (i.e. instances with no samples) may be replaced. If set DDS.BOOLEAN_TRUE, then a DDS.DataWriter will first try reclaiming empty instances, before trying to replace whatever is specified by DDS.DataWriterResourceLimitsQosPolicy.instance_replacement.

    [default] DDS.BOOLEAN_FALSE


    See also: DDS.DataWriterResourceLimitsInstanceReplacementKind

    Autoregister_Instances: Whether or not to automatically register new instances

    [default] DDS.BOOLEAN_FALSE

    When set to true, it is possible to write with a non-NIL handle of an instance that is not registered: the write operation will succeed and the instance will be registered. Otherwise, that write operation would fail.


    See also: FooDataWriter.write

    Initial_Virtual_Writers: The initial number of virtual writers supported by a DDS.DataWriter

    [default] 1

    [range] [1, 1000000], or DDS.LENGTH_UNLIMITED

    Max_Virtual_Writers: The maximum number of virtual writers supported by a DDS.DataWriter

    Sets the maximum number of unique virtual writers supported by a DDS.DataWriter, where virtual writers are added when samples are written with the virtual writer GUID.

    This field is specially relevant in the configuration of Persistence Service DataWriters since these DataWriters will publish samples on behalf of multiple virtual writers.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1000000], or DDS.LENGTH_UNLIMITED

    Max_Remote_Readers: The maximum number of remote readers supported by a DDS.DataWriter

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1000000], or DDS.LENGTH_UNLIMITED

    Max_App_Ack_Remote_Readers: The maximum number of application-level acknowledging remote readers supported by a DDS.DataWriter

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1000000], or DDS.LENGTH_UNLIMITED

    ServiceQosPolicyKind

    type ServiceQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of service

    QoS:
    DDS.ServiceQosPolicy

    ServiceQosPolicy

    type ServiceQosPolicy is record
          Kind : ServiceQosPolicyKind;
       end record  with Convention => C;

    Summary: Service associated with a DDS entity.

    This QoS policy is intended to be used by RTI infrastructure services.

    User applications should not modify its value.

    Entity:
    DDS.DomainParticipant, DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = NO
    "Changeable" = "UNTIL ENABLE"

    Kind: The kind of service.

    [default] DDS.NO_SERVICE_QOS

    PublisherProtocolQosPolicy

    type PublisherProtocolQosPolicy is record
          Vendor_Specific_Entity : DDS.Boolean := False;
       end record with Convention => C;

    SubscriberProtocolQosPolicy

    type SubscriberProtocolQosPolicy is record
          Vendor_Specific_Entity : DDS.Boolean := False;
       end record with Convention => C;

    DataReaderProtocolQosPolicy

    type DataReaderProtocolQosPolicy is record
          Virtual_Guid                                : aliased Guid_T;
          Rtps_Object_Id                              : aliased Unsigned_Long := RTPS_AUTO_ID;
          Expects_Inline_Qos                          : aliased DDS.Boolean := False;
          Disable_Positive_Acks                       : aliased DDS.Boolean := False;
          Propagate_Dispose_Of_Unregistered_Instances : aliased DDS.Boolean := False;
          Propagate_Unregister_Of_Disposed_Instances  : aliased DDS.Boolean := False;
          Rtps_Reliable_Reader                        : aliased RtpsReliableReaderProtocol_T := RTPS_RELIABLE_READER_PROTOCOL_DEFAULT;
          Vendor_Specific_Entity                      : aliased DDS.Boolean := False;
          Meta_Entity                                 : aliased DDS.Boolean := False;
       end record with Convention => C;

    Summary: Along with DDS.WireProtocolQosPolicy and DDS.DataWriterProtocolQosPolicy,this QoS policy configures the DDS on-the-network protocol (RTPS).

    DDS has a standard protocol for packet (user and meta data) exchange between applications using DDS for communications. This QoS policy and DDS.DataReaderProtocolQosPolicy give you control over configurable portions of the protocol, including the configuration of the reliable data delivery mechanism of the protocol on a per DataWriter or DataReader basis.

    These configuration parameters control timing, timeouts, and give you the ability to tradeoff between speed of data loss detection and repair versus network and CPU bandwidth used to maintain reliability.

    It is important to tune the reliability protocol (on a per DDS.DataWriter and DDS.DataReader basis) to meet the requirements of the end-user application so that data can be sent between DataWriters and DataReaders in an efficient and optimal manner in the presence of data loss.

    You can also use this QoS policy to control how RTI Connext responds to "slow" reliable DataReaders or ones that disconnect or are otherwise lost. See DDS.ReliabilityQosPolicy for more information on the per-DataReader/DataWriter reliability configuration. DDS.HistoryQosPolicy and DDS.ResourceLimitsQosPolicy also play an important role in the DDS reliable protocol.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Virtual_Guid: The virtual GUID (Global Unique Identifier).

    The virtual GUID is used to uniquely identify different incarnations of the same DDS.DataReader.

    The association between a DDS.DataReader and its persisted state is done using the virtual GUID.

    [default] DDS_GUID_AUTO

    Rtps_Object_Id: The RTPS Object ID.

    This value is used to determine the RTPS object ID of a data reader according to the DDS-RTPS Interoperability Wire Protocol.

    Only the last 3 bytes are used; the most significant byte is ignored.

    If the default value is specified, RTI Connext will automatically assign the object ID based on a counter value (per participant) starting at 0x00800000. That value is incremented for each new data reader.

    A rtps_object_id value in the interval [0x00800000,0x00ffffff] may collide with the automatic values assigned by dds. In those cases, the recomendation is not to use automatic object ID assigment.

    [default] DDS_RTPS_AUTO_ID

    [range] [0,0x00ffffff]

    Expects_Inline_Qos: Specifies whether this DataReader expects inline QoS with every sample.

    In dds, a DDS.DataReader nominally relies on Discovery to propagate QoS on a matched DDS.DataWriter. Alternatively, a DDS.DataReader may get information on a matched DDS.DataWriter through QoS sent inline with a sample.

    Asserting DDS.DataReaderProtocolQosPolicy.expects_inline_qos indicates to a matching DDS.DataWriter that this DDS.DataReader expects to receive inline QoS with every sample. The complete set of inline QoS that a DDS.DataWriter may send inline is specified by the Real-Time Publish-Subscribe (RTPS) Wire Interoperability Protocol.

    Because RTI Connext DDS.DataWriter and DDS.DataReader cache Discovery information, inline QoS are largely redundant and thus unecessary. Only for other stateless implementations whose DDS.DataReader does not cache Discovery information is inline QoS necessary.

    Also note that inline QoS are additional wire-payload that consume additional bandwidth and serialization and deserialization time.

    [default] DDS.BOOLEAN_FALSE

    disable_positive_acks: Whether the reader sends positive acknowledgements to writers.

    If set to DDS.BOOLEAN_TRUE, the reader does not send positive acknowledgments (ACKs) in response to Heartbeat messages. The reader will send negative acknowledgements (NACKs) when a Heartbeat advertises samples that it has not received.

    Otherwise, if set to DDS.BOOLEAN_FALSE (the default), the reader will send ACKs to writers that expect ACKs (DDS.DataWriterProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_FALSE) and it will not send ACKs to writers that disable ACKs (DDS.DataWriterProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE)

    [default] DDS.BOOLEAN_FALSE

    propagate_dispose_of_unregistered_instances: Indicates whether or not an instance can move to the DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE state without being in the DDS.ALIVE_INSTANCE_STATE state.

    This field only applies to keyed readers.

    When the field is set to DDS.BOOLEAN_TRUE, the DataReader will receive dispose notifications even if the instance is not alive.

    To guarantee the key availability through the usage of the API FooDataReader.get_key_value, this option should be used in combination DDS.DataWriterProtocolQosPolicy.serialize_key_with_dispose on the DataWriter that should be set to DDS.BOOLEAN_TRUE.

    [default] DDS.BOOLEAN_FALSE

    propagate_unregister_of_disposed_instances: Indicates whether or not an instance can move to the DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE state without being in the DDS.ALIVE_INSTANCE_STATE state.

    This field only applies to keyed readers.

    When the field is set to DDS.BOOLEAN_TRUE, the DataReader will receive unregister notifications even if the instance is not alive.

    [default] DDS.BOOLEAN_FALSE

    Rtps_Reliable_Reader: RTPS protocol-related configuration settings for the RTPS reliable reader associated to a DDS.DataReader. This parameter only has effect if the reader is configured with DDS.RELIABLE_RELIABILITY_QOS DDS.ReliabilityQosPolicyKind.

    For details, refer to the DDS.RtpsReliableReaderProtocol_t

    [default]
    min_heartbeat_response_delay 0.0 seconds;
    max_heartbeat_response_delay 0.5 seconds;
    heartbeat_suppression_duration 0.0625 seconds;
    nack_period 5.0 seconds;
    receive_window_size 256;
    round_trip_time 0.0 seconds;
    app_ack_period 5.0 seconds;
    samples_per_app_ack 1;

    DataWriterProtocolQosPolicy

    type DataWriterProtocolQosPolicy is record
          Virtual_Guid                       : aliased Guid_T;
          Rtps_Object_Id                     : aliased Unsigned_Long := RTPS_AUTO_ID;
          Push_On_Write                      : aliased DDS.Boolean := False;
          Disable_Positive_Acks              : aliased DDS.Boolean := False;
          Disable_Inline_Keyhash             : aliased DDS.Boolean := False;
          Serialize_Key_With_Dispose         : aliased DDS.Boolean := False;
          Propagate_App_Ack_With_No_Response : aliased DDS.Boolean := True;
          Rtps_Reliable_Writer               : aliased RtpsReliableWriterProtocol_T := RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT;
          Initial_Virtual_Sequence_Number    : aliased DDS.SequenceNumber_T := (-2147483648, 16#FFFF_FFFF#);
          Vendor_Specific_Entity             : aliased DDS.Boolean := False;
       end record with Convention => C;

    Summary: Protocol that applies only to DDS.DataWriter instances.

    DDS has a standard protocol for packet (user and meta data) exchange between applications using DDS for communications. This QoS policy and DDS.DataWriterProtocolQosPolicy give you control over configurable portions of the protocol, including the configuration of the reliable data delivery mechanism of the protocol on a per DataWriter or DataReader basis.

    These configuration parameters control timing, timeouts, and give you the ability to tradeoff between speed of data loss detection and repair versus network and CPU bandwidth used to maintain reliability.

    It is important to tune the reliability protocol (on a per DDS.DataWriter and DDS.DataReader basis) to meet the requirements of the end-user application so that data can be sent between DataWriters and DataReaders in an efficient and optimal manner in the presence of data loss.

    You can also use this QoS policy to control how RTI Connext responds to "slow" reliable DataReaders or ones that disconnect or are otherwise lost. See DDS.ReliabilityQosPolicy for more information on the per-DataReader/DataWriter reliability configuration. DDS.HistoryQosPolicy and DDS.ResourceLimitsQosPolicy also play an important role in the DDS reliable protocol.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Virtual_Guid: The virtual GUID (Global Unique Identifier).

    The virtual GUID is used to uniquely identify different incarnations of the same DDS.DataWriter.

    RTI Connext uses the virtual GUID to associate a persisted writer history to a specific DDS.DataWriter.

    The RTI Connext Persistence Service uses the virtual GUID to send samples on behalf of the original DDS.DataWriter.

    [default] DDS_GUID_AUTO

    Rtps_Object_Id: The RTPS Object ID.

    This value is used to determine the RTPS object ID of a data writer according to the DDS-RTPS Interoperability Wire Protocol.

    Only the last 3 bytes are used; the most significant byte is ignored.

    If the default value is specified, RTI Connext will automatically assign the object ID based on a counter value (per participant) starting at 0x00800000. That value is incremented for each new data writer.

    A rtps_object_id value in the interval [0x00800000,0x00ffffff] may collide with the automatic values assigned by dds. In those cases, the recomendation is not to use automatic object ID assigment.

    [default] DDS_RTPS_AUTO_ID

    [range] [0,0x00ffffff]

    Push_On_Write: Whether to push sample out when write is called.

    If set to DDS.BOOLEAN_TRUE (the default), the writer will send a sample every time write is called. Otherwise, the sample is put into thequeue waiting for a NACK from remote reader(s) to be sent out.

    [default] DDS.BOOLEAN_TRUE

    Disable_Positive_Acks: Controls whether or not the writer expects positive acknowledgements from matching readers.

    If set to DDS.BOOLEAN_TRUE, the writer does not expect readers to send send positive acknowledgments to the writer. Consequently, instead of keeping a sample queued until all readers have positively acknowledged it, the writer will keep a sample for at least DDS.RtpsReliableWriterProtocol_t.disable_positive_acks_min_sample_keep_duration, after which the sample is logically considered as positively acknowledged.

    If set to DDS.BOOLEAN_FALSE (the default), the writer expects to receive positive acknowledgements from its acknowledging readers (DDS.DataReaderProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_FALSE) and it applies the keep-duration to its non-acknowledging readers (DDS.DataReaderProtocolQosPolicy.disable_positive_acks = DDS.BOOLEAN_TRUE).

    A writer with both acknowledging and non-acknowledging readers keeps a sample queued until acknowledgements have been received from all acknowledging readers and the keep-duration has elapsed for non-acknowledging readers.

    [default] DDS.BOOLEAN_FALSE

    Disable_Inline_Keyhash: Controls whether or not a keyhash is propagated on the wire with each sample.

    This field only applies to keyed writers.

    With each key, RTI Connext associates an internal 16-byte representation, called a keyhash.

    When this field is DDS.BOOLEAN_FALSE, the keyhash is sent on the wire with every data instance.

    When this field is DDS.BOOLEAN_TRUE, the keyhash is not sent on the wire and the readers must compute the value using the received data.

    If the reader is CPU bound, sending the keyhash on the wire may increase performance, because the reader does not have to get the keyhash from the data.

    If the writer is CPU bound, sending the keyhash on the wire may decrease performance, because it requires more bandwidth (16 more bytes per sample).

    Note: Setting disable_inline_keyhash to DDS.BOOLEAN_TRUE is not compatible with using RTI Real-Time Connect or RTI Recorder.

    [default] DDS.BOOLEAN_FALSE

    Serialize_Key_With_Dispose: Controls whether or not the serialized key is propagated on the wire with dispose samples.

    This field only applies to keyed writers.

    We recommend setting this field to DDS.BOOLEAN_TRUE if there are DataReaders where DDS.DataReaderProtocolQosPolicy.propagate_dispose_of_unregistered_instances is also DDS.BOOLEAN_TRUE.

    Important: When this field is DDS.BOOLEAN_TRUE, batching will not be compatible with RTI Connext 4.3e, 4.4b, or 4.4c. The DDS.DataReader entities will receive incorrect data and/or encounter deserialization errors.

    [default] DDS.BOOLEAN_FALSE

    Propagate_App_Ack_With_No_Response: Controls whether or not a DDS.DataWriter receives DDS.DataWriterListener.on_application_acknowledgment notifications with an empty or invalid response.

    When this field is set to DDS.BOOLEAN_FALSE, the callback DDS.DataWriterListener.on_application_acknowledgment will not be invoked if the sample being acknowledged has an empty or invalid response.

    [default] DDS.BOOLEAN_TRUE

    Rtps_Reliable_Writer: RTPS protocol-related configuration settings for the RTPS reliable writer associated to a DDS.DataWriter. This parameter only has effect if both the writer and the matching reader are configured with DDS.RELIABLE_RELIABILITY_QOS DDS.ReliabilityQosPolicyKind.

    For details, refer to the DDS.RtpsReliableWriterProtocol_t

    [default]
    low_watermark 0;
    high_watermark 1;
    heartbeat_period 3.0 seconds;
    fast_heartbeat_period 3.0 seconds;
    late_joiner_heartbeat_period 3.0 seconds;
    virtual_heartbeat_period DDS_DURATION_AUTO;
    samples_per_virtual_heartbeat DDS.LENGTH_UNLIMITED;
    max_heartbeat_retries 10;
    inactivate_nonprogressing_readers DDS.BOOLEAN_FALSE;
    heartbeats_per_max_samples 8;
    min_nack_response_delay 0.0 seconds;
    max_nack_response_delay 0.2 seconds;
    nack_suppression_duration 0.0 seconds;
    max_bytes_per_nack_response 131072 bytes;
    disable_positive_acks_min_sample_keep_duration 1.0 milliseconds;
    disable_positive_acks_max_sample_keep_duration 1.0 seconds;
    disable_positive_acks_enable_adaptive_sample_keep_duration DDS.BOOLEAN_TRUE;
    disable_positive_acks_decrease_sample_keep_duration_factor 95;
    disable_positive_acks_increase_sample_keep_duration_factor 150;
    min_send_window_size DDS.LENGTH_UNLIMITED;
    max_send_window_size DDS.LENGTH_UNLIMITED;
    send_window_update_period 3s;
    send_window_increase_factor 105;
    send_window_decrease_factor 70;
    enable_multicast_periodic_heartbeat DDS.BOOLEAN_FALSE;
    multicast_resend_threshold 2 readers;

    Initial_Virtual_Sequence_Number: Determines, the initial virtual sequence number for this DataWriter.

    By default, the sequence number will be (0,1) for DataWriters that do not use durable writer history.

    For durable writers the sequence number will be the last sequence number they published in a previous execution plus one.

    [default] DDS_AUTO_SEQUENCE_NUMBER

    SystemResourceLimitsQosPolicy

    type SystemResourceLimitsQosPolicy is record
          Max_Objects_Per_Thread : Long := 1024;
       end record with Convention => C;

    Summary: <<ext>> Configures DDS.DomainParticipant-independent resources used by dds. Mainly used to change the maximum number of DDS.DomainParticipant entities that can be created within a single process (address space).

    Entity:
    DDS.DomainParticipantFactory

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    Within a single process (or address space for some supported real-time operating systems), applications may create and use multiple DDS.DomainParticipant entities. This QoS policy sets a parameter that places an effective upper bound on the maximum number of DDS.DomainParticipant entities that can be created in a single process/address space.

    Max_Objects_Per_Thread: The maximum number of objects that can be stored per thread for a DDS.DomainParticipantFactory.

    Before increasing this value to allow you to create more participants, carefully consider the application design that requires you to create so many participants. Remember: a DDS.DomainParticipant is a heavy-weight object. It spawns several threads and maintains its own discovery database (see DDSDiscoveryQosModule). Creating more participants than RTI Connext strictly requires -- one per domain per process/address space -- can adversely affect the performance and resource utilization of your application.

    [default] 1024; this value allows you to create about 10 or 11 DDS.DomainParticipant entities.

    [range] [1, 1 billion]

    DomainParticipantResourceLimitsIgnoredEntityReplacementKind

    type DomainParticipantResourceLimitsIgnoredEntityReplacementKind is new Unsigned_Long;

    Summary: Available replacement policies for the ignored entities.

    QoS:
    DDS.DomainParticipantResourceLimitsQosPolicy

    DomainParticipantResourceLimitsQosPolicy

    type DomainParticipantResourceLimitsQosPolicy is record
          Local_Writer_Allocation                               : aliased AllocationSettings_T := (16, -1, -1);
          Local_Reader_Allocation                               : aliased AllocationSettings_T := (16, -1, -1);
          Local_Publisher_Allocation                            : aliased AllocationSettings_T := (4, -1, -1);
          Local_Subscriber_Allocation                           : aliased AllocationSettings_T := (4, -1, -1);
          Local_Topic_Allocation                                : aliased AllocationSettings_T := (16, -1, -1);
          Remote_Writer_Allocation                              : aliased AllocationSettings_T := (64, -1, -1);
          Remote_Reader_Allocation                              : aliased AllocationSettings_T := (64, -1, -1);
          Remote_Participant_Allocation                         : aliased AllocationSettings_T := (16, -1, -1);
          Matching_Writer_Reader_Pair_Allocation                : aliased AllocationSettings_T := (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1);
          Matching_Reader_Writer_Pair_Allocation                : aliased AllocationSettings_T := (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1);
          Ignored_Entity_Allocation                             : aliased AllocationSettings_T := (8, -1, -1);
          Content_Filtered_Topic_Allocation                     : aliased AllocationSettings_T := (4, -1, -1);
          Content_Filter_Allocation                             : aliased AllocationSettings_T := (4, -1, -1);
          Read_Condition_Allocation                             : aliased AllocationSettings_T := (4, -1, -1);
          Query_Condition_Allocation                            : aliased AllocationSettings_T := (4, -1, -1);
          Outstanding_Asynchronous_Sample_Allocation            : aliased AllocationSettings_T := (64, -1, -1);
          Flow_Controller_Allocation                            : aliased AllocationSettings_T := (4, -1, -1);
          Local_Writer_Hash_Buckets                             : aliased Long := 4;
          Local_Reader_Hash_Buckets                             : aliased Long := 4;
          Local_Publisher_Hash_Buckets                          : aliased Long := 1;
          Local_Subscriber_Hash_Buckets                         : aliased Long := 1;
          Local_Topic_Hash_Buckets                              : aliased Long := 4;
          Remote_Writer_Hash_Buckets                            : aliased Long := 16;
          Remote_Reader_Hash_Buckets                            : aliased Long := 16;
          Remote_Participant_Hash_Buckets                       : aliased Long := 4;
          Matching_Writer_Reader_Pair_Hash_Buckets              : aliased Long := 32;
          Matching_Reader_Writer_Pair_Hash_Buckets              : aliased Long := 32;
          Ignored_Entity_Hash_Buckets                           : aliased Long := 1;
          Content_Filtered_Topic_Hash_Buckets                   : aliased Long := 1;
          Content_Filter_Hash_Buckets                           : aliased Long := 1;
          Flow_Controller_Hash_Buckets                          : aliased Long := 1;
          Max_Gather_Destinations                               : aliased Long := 8;
          Participant_User_Data_Max_Length                      : aliased Long := 256;
          Inter_Participant_Data_Max_Length                     : aliased Long := 256;
          Topic_Data_Max_Length                                 : aliased Long := 256;
          Publisher_Group_Data_Max_Length                       : aliased Long := 256;
          Subscriber_Group_Data_Max_Length                      : aliased Long := 256;
          Writer_User_Data_Max_Length                           : aliased Long := 256;
          Reader_User_Data_Max_Length                           : aliased Long := 256;
          Max_Partitions                                        : aliased Long := 64;
          Max_Partition_Cumulative_Characters                   : aliased Long := 256;
          Default_Partition_Matches_All                         : aliased Boolean := False;
          Allow_No_Partitions                                   : aliased Boolean := False;
          Type_Code_Max_Serialized_Length                       : aliased Long := 2048;
          Type_Object_Max_Serialized_Length                     : aliased Long := 2048;
          Serialized_Type_Object_Dynamic_Allocation_Threshold   : aliased Long := 2048;
          Type_Object_Max_Deserialized_Length                   : aliased Long := -1;
          Deserialized_Type_Object_Dynamic_Allocation_Threshold : aliased Long := 4096;
          Contentfilter_Property_Max_Length                     : aliased Long := 256;
          Channel_Seq_Max_Length                                : aliased Long := 32;
          Channel_Filter_Expression_Max_Length                  : aliased Long := 256;
          Participant_Property_List_Max_Length                  : aliased Long := 32;
          Participant_Property_String_Max_Length                : aliased Long := 4096;
          Writer_Property_List_Max_Length                       : aliased Long := 32;
          Writer_Property_String_Max_Length                     : aliased Long := 1024;
          Reader_Property_List_Max_Length                       : aliased Long := 32;
          Reader_Property_String_Max_Length                     : aliased Long := 1024;
          Plugin_Info_Parameter_Max_Length                      : aliased Long := 265;
          Max_Endpoint_Groups                                   : aliased Long := 32;
          Max_Endpoint_Group_Cumulative_Characters              : aliased Long := 1024;
          Transport_Info_List_Max_Length                        : aliased Long := 12;
          Ignored_Entity_Replacement_Kind                       : aliased DomainParticipantResourceLimitsIgnoredEntityReplacementKind
            := NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT;
          Remote_Topic_Query_Allocation                         : aliased AllocationSettings_T := (1, -1, -1);
          Remote_Topic_Query_Hash_Buckets                       : aliased Long := 1;
       end record with Convention => C;

    Summary: Various settings that configure how a DDS.DomainParticipant allocates and uses physical memory for internal resources, including the maximum sizes of various properties.

    This QoS policy sets maximum size limits on variable-length parameters used by the participant and its contained Entities. It also controls the initial and maximum sizes of data structures used by the participant to store information about locally-created and remotely-discovered entities (such as DataWriters/DataReaders), as well as parameters used by the internal database to size the hash tables it uses.

    By default, a DDS.DomainParticipant is allowed to dynamically allocate memory as needed as users create local Entities such as DDS.DataWriter and DDS.DataReader or as the participant discovers new applications to store their information. By setting fixed values for the maximum parameters in this QosPolicy, you can bound the memory that can be allocated by a DomainParticipant. In addition, by setting the initial values to the maximum values, you can reduce the amount of memory allocated by DomainParticipants after the initialization period. Notice that memory can still be allocated dynamically after the initialization period. For example, when a new local DDS.DataWriter or DDS.DataReader is created, the initial memory required for its queue is allocated dynamically.

    The maximum sizes of different variable-length parameters such as the number of partitions that can be stored in the DDS.PartitionQosPolicy, the maximum length of data store in the DDS.UserDataQosPolicy and DDS.GroupDataQosPolicy, and many others can be changed from their defaults using this QoS policy. However, it is important that all DomainParticipants that need to communicate with each other use the same set of maximum values. Otherwise, when these parameters are propagated from one DDS.DomainParticipant to another, a DDS.DomainParticipant with a smaller maximum length may reject the parameter, resulting in an error.

    An important parameter in this QoS policy that is often changed by users is DDS.DomainParticipantResourceLimitsQosPolicy.type_code_max_serialized_length.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    local_writer_allocation: Allocation settings applied to local DataWriters.

    [default] initial_count = 16; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    local_reader_allocation: Allocation settings applied to local DataReaders.

    [default] initial_count = 16; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    local_publisher_allocation: Allocation settings applied to local Publisher.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    local_subscriber_allocation: Allocation settings applied to local Subscriber.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    local_topic_allocation: Allocation settings applied to local Topic.

    [default] initial_count = 16; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    remote_writer_allocation: Allocation settings applied to remote DataWriters.

    Remote DataWriters include all DataWriters, both local and remote.

    [default] initial_count = 64; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    remote_reader_allocation: Allocation settings applied to remote DataReaders.

    Remote DataReaders include all DataReaders, both local and remote.

    [default] initial_count = 64; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    remote_partiicpant_allocation: Allocation settings applied to remote DomainParticipants.

    Remote DomainParticipants include all DomainParticipants, both local and remote.

    [default] initial_count = 16; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    matching_writer_reader_pair_allocation: Allocation settings applied to matching local writer and remote/local reader pairs.

    [default] initial_count = 32; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    matching_reader_writer_pair_allocation: Allocation settings applied to matching local reader and remote/local writer pairs.

    [default] initial_count = 32; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    ignored_entity_allocation: Allocation settings applied to ignored entities.

    [default] initial_count = 8; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    content_filtered_topic_allocation: Allocation settings applied to content filtered topic.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    content_filter_allocation: Allocation settings applied to content filter.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED; incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    read_condition_allocation: Allocation settings applied to read condition pool.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED, incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    query_condition_allocation: Allocation settings applied to query condition pool.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED, incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    outstanding_asynchronous_sample_allocation: Allocation settings applied to the maximum number of samples (from all DDS.DataWriter) waiting to be asynchronously written.

    [default] initial_count = 64; max_count = DDS.LENGTH_UNLIMITED, incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    flow_controller_allocation: Allocation settings applied to flow controllers.

    [default] initial_count = 4; max_count = DDS.LENGTH_UNLIMITED, incremental_count = -1

    [range] See allowed ranges in struct DDS.AllocationSettings_t

    local_writer_hash_buckets: Hash_Buckets settings applied to local DataWriters.

    [default] 4

    [range] [1, 10000]

    local_reader_hash_buckets: Number of hash buckets for local DataReaders.

    [default] 4

    [range] [1, 10000]

    local_publisher_hash_buckets: Number of hash buckets for local Publisher.

    [default] 1

    [range] [1, 10000]

    local_subscriber_hash_buckets: Number of hash buckets for local Subscriber.

    [default] 1

    [range] [1, 10000]

    local_topic_hash_buckets: Number of hash buckets for local Topic.

    [default] 4

    [range] [1, 10000]

    remote_writer_hash_buckets: Number of hash buckets for remote DataWriters.

    Remote DataWriters include all DataWriters, both local and remote.

    [default] 16

    [range] [1, 10000]

    remote_reader_hash_buckets: Number of hash buckets for remote DataReaders.

    Remote DataReaders include all DataReaders, both local and remote.

    [default] 16

    [range] [1, 10000]

    remote_participant_hash_buckets: Number of hash buckets for remote DomainParticipants.

    Remote DomainParticipants include all DomainParticipants, both local and remote.

    [default] 4

    [range] [1, 10000]

    matching_writer_reader_pair_hash_buckets: Number of hash buckets for matching local writer and remote/local reader pairs.

    [default] 32

    [range] [1, 10000]

    matching_reader_writer_pair_hash_buckets: Number of hash buckets for matching local reader and remote/local writer pairs.

    [default] 32

    [range] [1, 10000]

    ignored_entity_hash_buckets: Number of hash buckets for ignored entities.

    [default] 1

    [range] [1, 10000]

    content_filtered_topic_hash_buckets: Number of hash buckets for content filtered topics.

    [default] 1

    [range] [1, 10000]

    content_filter_hash_buckets: Number of hash buckets for content filters.

    [default] 1

    [range] [1, 10000]

    flow_controller_hash_buckets: Number of hash buckets for flow controllers.

    [default] 1

    [range] [1, 10000]

    max_gather_destinations: Maximum number of destinations per RTI Connext send.

    When RTI Connext sends out a message, it has the capability to send to multiple destinations to be more efficient. The maximum number of destinations per RTI Connext send is specified by max_gather_destinations.

    [default] 8

    [range] [4, 1 million]

    participant_user_data_max_length: Maximum length of user data in DDS.DomainParticipantQos and DDS.ParticipantBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    topic_data_max_length: Maximum length of topic data in DDS.TopicQos, DDS.TopicBuiltinTopicData, DDS.PublicationBuiltinTopicData and DDS.SubscriptionBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    publisher_group_data_max_length: Maximum length of group data in DDS.PublisherQos and DDS.PublicationBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    subscriber_group_data_max_length: Maximum length of group data in DDS.SubscriberQos and DDS.SubscriptionBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    writer_user_data_max_length: Maximum length of user data in DDS.DataWriterQos and DDS.PublicationBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    reader_user_data_max_length: Maximum length of user data in DDS.DataReaderQos and DDS.SubscriptionBuiltinTopicData

    [default] 256

    [range] [0,0x7fffffff]

    max_partitions: Maximum number of partition name strings allowable in a DDS.PartitionQosPolicy.

    This setting is made on a per DomainParticipant basis; it cannot be set individually on a per Publisher/Subscriber basis. However, the limit is enforced and applies per Publisher/Subscriber.

    This value cannot exceed 64.

    [default] 64

    [range] [0,64]

    max_partition_cumulative_characters: Maximum number of combined characters allowable in all partition names in a DDS.PartitionQosPolicy.

    The maximum number of combined characters should account for a terminating NULL ('\0') character for each partition name string.

    This setting is made on a per DomainParticipant basis; it cannot be set individually on a per Publisher/Subscriber basis. However, the limit is enforced and applies per Publisher/Subscriber.

    This value cannot exceed 256.

    [default] 256

    [range] [0,256]

    type_code_max_serialized_length: Maximum size of serialized string for type code.

    This parameter limits the size of the type code that a DDS.DomainParticipant is able to store and propagate for user data types. Type codes can be used by external applications to understand user data types without having the data type predefined in compiled form. However, since type codes contain all of the information of a data structure, including the strings that define the names of the members of a structure, complex data structures can result in type codes larger than the default maximum of 2048 bytes. So it is common for users to set this parameter to a larger value. However, as with all parameters in this QoS policy defining maximum sizes for variable-length elements, all DomainParticipants in the same domain should use the same value for this parameter.

    [default] 2048

    [range] [0,0xffff]

    Type_Object_Max_Serialized_Length: The maximum length, in bytes, that the buffer to serialize a TypeObject can consume.

    This parameter limits the size of the TypeObject that a DomainParticipant is able to propagate. Since TypeObjects contain all of the information of a data structure, including the strings that define the names of the members of a structure, complex data structures can result in TypeObjects larger than the default maximum of 3072 bytes. This field allows you to specify a larger value. The desired size for a given DDS_TypeCode can be obtained using DDS_TypeCode.get_type_object_serialized_size.

    [default] 3072

    [range] [0,0x7fffffff]

    Type_Object_Max_Deserialized_Length: The maximum number of bytes that a deserialized TypeObject can consume.

    This parameter limits the size of the TypeObject that a DomainParticipant is able to store.

    [default] DDS.LENGTH_UNLIMITED

    [range] [0,0x7fffffff] or DDS.LENGTH_UNLIMITED

    Deserialized_Type_Object_Dynamic_Allocation_Threshold: A threshold, in bytes, for dynamic memory allocation for the deserialized TypeObject.

    Above this threshold, the memory for a TypeObject is allocated dynamically. Below it, the memory is obtained from a pool of fixed-size buffers. The size of the buffers is equal to this threshold.

    [default] 4096

    [range] [0,0x7fffffff] <= DDS.DomainParticipantResourceLimitsQosPolicy.type_object_max_deserialized_length

    contentfilter_property_max_length: This field is the maximum length of all data related to a Content-filtered topic.

    This is the sum of the length of the ContentFilteredTopic name, the length of the related topic name, the length of the filter expression, the length of the filter parameters, and the length of the filter name. The maximum number of combined characters should account for a terminating NULL ('\0') character for each string.

    [default] 256

    [range] [0,0xffff]

    channel_seq_max_length: Maximum number of channels that can be specified in DDS.MultiChannelQosPolicy for MultiChannel DataWriters.

    [default] 32

    [range] [0,0xffff]

    channel_filter_expression_max_length: Maximum length of a channel DDS.ChannelSettings_t.filter_expression in a MultiChannel DataWriter.

    The length should account for a terminating NULL ('\0') character.

    [default] 256

    [range] [0,0xffff]

    participant_property_list_max_length: Maximum number of properties associated with the DDS.DomainParticipant.

    [default] 32

    [range] [0,0xffff]

    participant_property_string_max_length: Maximum string length of the properties associated with the DDS.DomainParticipant.

    The string length is defined as the cumulative length in bytes, including the null terminating characters, of all the pair (name,value) associated with the DDS.DomainParticipant properties.

    [default] 2048

    [range] [0,0xffff]

    writer_property_list_max_length: Maximum number of properties associated with a DDS.DataWriter.

    [range] [0,0xffff]

    [default] 32

    writer_property_string_max_length: Maximum string length of the properties associated with a DDS.DataWriter.

    The string length is defined as the cumulative length in bytes, including the null terminating characters, of all the pair (name,value) associated with the DDS.DataWriter properties.

    [default] 1024

    [range] [0,0xffff]

    reader_property_list_max_length: Maximum number of properties associated with a DDS.DataReader.

    [default] 32

    [range] [0,0xffff]

    reader_property_string_max_length: Maximum string length of the properties associated with a DDS.DataReader.

    The string length is defined as the cumulative length in bytes, including the null terminating characters, of all the pair (name,value) associated with a DDS.DataReader properties.

    [default] 1024

    [range] [0,0xffff]

    max_endpoint_groups: Maximum number of DDS.EndpointGroup_t allowable in a DDS.AvailabilityQosPolicy.

    [default] 32

    [range] [0,65535]

    max_endpoint_group_cumulative_characters: Maximum number of combined role_name characters allowable in all DDS.EndpointGroup_t in a DDS.AvailabilityQosPolicy.

    The maximum number of combined characters should account for a terminating NULL character for each role_name string.

    [default] 1024

    [range] [0,65535]

    transport_info_list_max_length: Maximum number of installed transports to send and receive information about in DDS.ParticipantBuiltinTopicData.transport_info.

    [default] 6

    [range] [0,100]

    ignored_entity_replacement_kind: Replacement policy for the ignored entities. It sets what entity can be replaced when resource limits set in DDS.DomainParticipantResourceLimitsQosPolicy.ignored_entity_allocation are reached.

    When a DDS.DomainParticipant's number of ignored entities is greater than DDS.DomainParticipantResourceLimitsQosPolicy.ignored_entity_allocation, it will try to make room by replacing an existing ignored participant entry. This field specifies what entity is allowed to be replaced.

    If a replaceable participant entry is not available, an out-of-resources exception will be returned.

    [default] DDS.NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT


    See also: DDS.DomainParticipantResourceLimitsIgnoredEntityReplacementKind

    EventQosPolicy

    type EventQosPolicy is record
          Thread        : aliased ThreadSettings_T;
          Initial_Count : aliased Long := 256;
          Max_Count     : aliased Long := -1;
       end record with Convention => C;

    Summary: Settings for event.

    In a DDS.DomainParticipant, a thread is dedicated to handle all timed events, including checking for timeouts and deadlines and executing internal and user-defined timeout or exception handling routines/callbacks.

    This QoS policy allows you to configure thread properties such as priority level and stack size. You can also configure the maximum number of events that can be posted to the event thread. By default, a DDS.DomainParticipant will dynamically allocate memory as needed for events posted to the event thread. However, by setting a maximum value or setting the initial and maximum value to be the same, you can either bound the amount of memory allocated for the event thread or prevent a DDS.DomainParticipant from dynamically allocating memory for the event thread after initialization.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Thread: Event thread QoS.

    There is only one event thread.

    Priority:
    [default] The actual value depends on your architecture:
    For Windows: -2
    For Linux: OS default priority
    For a complete list of platform specific values, please refer to Platform Notes .

    Stack Size:
    [default] The actual value depends on your architecture:
    For Windows: OS default stack size
    For Linux: OS default stack size
    For a complete list of platform specific values, please refer to ef_url_platform_notes.

    Mask:
    [default] mask = DDS.THREAD_SETTINGS_FLOATING_POINT | DDS.THREAD_SETTINGS_STDIO

    Initial_Count: The initial number of events.

    [default] 256

    [range] [1, 1 million], <= max_count

    Max_Count: The maximum number of events.

    The maximum number of events. If the limit is reached, no new event can be added.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_count

    DatabaseQosPolicy

    type DatabaseQosPolicy is record
          Thread                      : aliased ThreadSettings_T;
          Shutdown_Timeout            : aliased Duration_T := (15, 0);
          Cleanup_Period              : aliased Duration_T := (61, 0);
          Shutdown_Cleanup_Period     : aliased Duration_T := (1, 0);
          Initial_Records             : aliased Long := 1024;
          Max_Skiplist_Level          : aliased Long := 7;
          Table_Allocation_Block_Size : aliased Long := 48;
          Max_Weak_References         : aliased Long := -1;
          Initial_Weak_References     : aliased Long := 2049;
       end record with Convention => C;

    Summary: Various threads and resource limits settings used by RTI Connext to control its internal database.

    RTI uses an internal in-memory "database" to store information about entities created locally as well as remote entities found during the discovery process. This database uses a background thread to garbage-collect records related to deleted entities. When the DDS.DomainParticipant that maintains this database is deleted, it shuts down this thread.

    The Database QoS policy is used to configure how RTI Connext manages its database, including how often it cleans up, the priority of the database thread, and limits on resources that may be allocated by the database.

    You may be interested in modifying the DDS.DatabaseQosPolicy.shutdown_timeout and DDS.DatabaseQosPolicy.shutdown_cleanup_period parameters to decrease the time it takes to delete a DDS.DomainParticipant when your application is shutting down.

    The DDS.DomainParticipantResourceLimitsQosPolicy controls the memory allocation for elements stored in the database.

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" "NO"

    Thread: Database thread settings.

    There is only one database thread: the clean-up thread.

    [default] Priority: LOW.
    The actual value depends on your architecture:

    For Windows: -3
    For Linux: OS default priority
    For a complete list of platform specific values, please refer to Platform Notes .

    [default] Stack Size: The actual value depends on your architecture:

    For Windows: OS default stack size
    For Linux: OS default stack size
    For a complete list of platform specific values, please refer to ef_url_platform_notes.

    [default] Mask: DDS.THREAD_SETTINGS_STDIO

    Shutdown_Timeout: The maximum wait time during a shutdown.

    The domain participant will exit after the timeout, even if the database has not been fully cleaned up.

    [default] 15 seconds

    [range] [0,DDS_DURATION_INFINITE]

    Cleanup_Period: The database thread will wake up at this rate to clean up the database.

    [default] 61 seconds

    [range] [0,1 year]

    Shutdown_Cleanup_Period: The clean-up period used during database shut-down.

    [default] 1 second

    [range] [0,1 year]

    Initial_Records: The initial number of total records.

    [default] 1024

    [range] [1,10 million]

    Max_Skiplist_Level: The maximum level of the skiplist.

    The skiplist is used to keep records in the database. Usually, the search time is log2(N), where N is the total number of records in one skiplist. However, once N exceeds 2^n, where n is the maximum skiplist level, the search time will become more and more linear. Therefore, the maximum level should be set such that 2^n is larger than the maximum(N among all skiplists). Usually, the maximum N is the maximum number of remote and local writers or readers.

    [default] 14

    [range] [1,31]

    Max_Weak_References: The maximum number of weak references.

    A weak reference is an internal data structure that refers to a record within dds' internal database. This field configures the maximum number of such references that RTI Connext may create.

    The actual number of weak references is permitted to grow from an initial value (indicated by DDS.DatabaseQosPolicy.initial_weak_references) to this maximum. To prevent RTI Connext from allocating any weak references after the system has reached a steady state, set the initial and maximum values equal to one another. To indicate that the number of weak references should continue to grow as needed indefinitely, set this field to DDS.LENGTH_UNLIMITED. Be aware that although a single weak reference occupies very little memory, allocating a very large number of them can have a significant impact on your overall memory usage.

    Tuning this value precisely is difficult without intimate knowledge of the structure of dds' database; doing so is an advanced feature not required by most applications. The default value has been chosen to be sufficient for reasonably large systems. If you believe you may need to modify this value, please consult with RTI support personnel for assistance.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 100 million] or DDS.LENGTH_UNLIMITED, >= initial_weak_references


    See also: DDS.DatabaseQosPolicy.initial_weak_references

    Initial_Weak_References: The initial number of weak references.

    See DDS.DatabaseQosPolicy.max_weak_references for more information about what a weak reference is.

    If the QoS set contains an initial_weak_references value that is too small to ever grow to DDS.DatabaseQosPolicy.max_weak_references using dds' internal algorithm, this value will be adjusted upwards as necessary. Subsequent accesses of this value will reveal the actual initial value used.

    Changing the value of this field is an advanced feature; it is recommended that you consult with RTI support personnel before doing so.

    [default] 2049, which is the minimum initial value imposed by REDA when the maximum is unlimited. If a lower value is specified, it will simply be increased to 2049 automatically.

    [range] [1, 100 million], <= max_weak_references


    See also: DDS.DatabaseQosPolicy.max_weak_references

    ReceiverPoolQosPolicy

    type ReceiverPoolQosPolicy is record
          Thread                  : aliased ThreadSettings_T;
          Initial_Receive_Threads : aliased Long := 4;
          Max_Receive_Threads     : aliased Long := ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT;
          Buffer_Size             : aliased Long := 9216;
          Buffer_Alignment        : aliased Long := 16;
          Is_Timestamp_Enabled    : aliased DDS.Boolean := True;
       end record with Convention => C;

    Summary: Configures threads used by RTI Connext to receive and process data from transports (for example, UDP sockets).

    This QoS policy is an extension to the DDS standard.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"


    See also: ThreadSettingsCpuRotationKind_usage

    Usage

    This QoS policy sets the thread properties such as priority level and stack size for the threads used by the middleware to receive and process data from transports.

    RTI uses a separate receive thread per port per transport plug-in. To force RTI Connext to use a separate thread to process the data for a DDS.DataReader, set a unique port for the DDS.TransportUnicastQosPolicy or DDS.TransportMulticastQosPolicy for the DDS.DataReader.

    This QoS policy also sets the size of the buffer used to store packets received from a transport. This buffer size will limit the largest single packet of data that a DDS.DomainParticipant will accept from a transport. Users will often set this size to the largest packet that any of the transports used by their application will deliver. For many applications, the value 65,536 (64 K) is a good choice; this value is the largest packet that can be sent/received via UDP.

    Thread: Receiver pool thread(s).

    There is at least one receive thread, possibly more.

    [default] priority above normal.
    The actual value depends on your architecture:

    For Windows: 2
    For Linux: OS default priority
    For a complete list of platform specific values, please refer to Platform Notes .

    [default] The actual value depends on your architecture:

    For Windows: OS default stack size
    For Linux: OS default stack size
    For a complete list of platform specific values, please refer to ef_url_platform_notes.

    [default] mask DDS.THREAD_SETTINGS_FLOATING_POINT | DDS.THREAD_SETTINGS_STDIO

    Buffer_Size: The receive buffer size.

    The receive buffer is used by the receive thread to store the raw data that arrives over the transport.

    In many applications, users will change the configuration of the built-in transport NDDS_Transport_Property_t.message_size_max to increase the size ofthe largest data packet that can be sent or received through thetransport. Typically, users will change the UDPv4 transportplugin's NDDS_Transport_Property_t.message_size_max to 65536 (64 K), which is the largest packet that can be sent/received via UDP.

    If you change buffer_size from its default value of LENGTH_AUTO, it should be set to be the same value as the maximum NDDS_Transport_Property_t.message_size_max across all of the transports being used that are not doing zero-copy (described below).

    If your application only uses transports that support zero-copy, buffer_size does not need to be greater than NDDS_Transport_Property_t.message_size_max.

    Transports that support zero-copy do not copy their data into the buffer provided by the receive thread. Instead, they provide the receive thread data in a buffer allocated by the transport itself. The built-in transports that support zero-copy are the SHMEM transport, and the UDPv4 transport on VxWorks platforms.

    buffer_size may be deprecated in the future.

    [default] DDS.LENGTH_AUTO

    [range] [1, 1 GB] or DDS.LENGTH_AUTO

    Buffer_Alignment: The receive buffer alignment.

    Most users will not need to change this alignment.

    [default] 16

    [range] [1,1024] Value must be a power of 2.

    BuiltinTopicReaderResourceLimits_T

    type BuiltinTopicReaderResourceLimits_T is record
          Initial_Samples                          : aliased Long := 64;
          Max_Samples                              : aliased Long := -1;
          Initial_Infos                            : aliased Long := 64;
          Max_Infos                                : aliased Long := -1;
          Initial_Outstanding_Reads                : aliased Long := 2;
          Max_Outstanding_Reads                    : aliased Long := -1;
          Max_Samples_Per_Read                     : aliased Long := 1024;
          Disable_Fragmentation_Support            : aliased DDS.Boolean := False;
          Max_Fragmented_Samples                   : aliased Long := 1024;
          Initial_Fragmented_Samples               : aliased Long := 4;
          Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 256;
          Max_Fragments_Per_Sample                 : aliased Long := 512;
          Dynamically_Allocate_Fragmented_Samples  : aliased DDS.Boolean := False;
       end record with Convention => C;

    Summary: Built-in topic reader's resource limits.

    Defines the resources that can be used for a built-in-topic data reader.

    A built-in topic data reader subscribes reliably to built-in topics containing declarations of new entities or updates to existing entities in the domain. Keys are used to differentiate among entities of the same type. RTI Connext assigns a unique key to each entity in a domain.

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    QoS:
    DDS.DiscoveryConfigQosPolicy

    Initial_Samples: Initial number of samples.

    This should be a value between 1 and initial number of instance of the built-in-topic reader, depending on how many instances are sending data concurrently.

    [default] 64

    [range] [1, 1 million], <= max_samples

    Max_Samples: Maximum number of samples.

    This should be a value between 1 and max number of instance of the built-in-topic reader, depending on how many instances are sending data concurrently. Also, it should not be less than initial_samples.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_samples

    Initial_Infos: Initial number of sample infos.

    The initial number of info units that a built-in topic DDS.DataReader can have. Info units are used to store DDS.SampleInfo.

    [default] 64

    [range] [1, 1 million] <= max_infos

    Max_Infos: Maximum number of sample infos.

    The maximum number of info units that a built-in topic DDS.DataReader can use to store DDS.SampleInfo.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED, >= initial_infos

    Initial_Outstanding_Reads: The initial number of outstanding reads that have not call finish yet on the same built-in topic DDS.DataReader.

    [default] 2

    [range] [1, 65536] or DDS.LENGTH_UNLIMITED <= max_outstanding_reads

    Max_Outstanding_Reads: The maximum number of outstanding reads that have not called finish yet on the same built-in topic DDS.DataReader.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 65536] or DDS.LENGTH_UNLIMITED, >= initial_outstanding_reads

    Max_Samples_Per_Read: Maximum number of samples that can be read/taken on a same built-in topic DDS.DataReader.

    [default] 1024

    [range] [1, 65536]

    Disable_Fragmentation_Support: Determines whether the built-in topic DDS.DataReader can receive fragmented samples.

    When fragmentation support is not needed, disabling fragmentation support will save some memory resources.

    [default] DDS.BOOLEAN_FALSE

    Max_Fragmented_Samples: The maximum number of samples for which the built-in topic DDS.DataReader may store fragments at a given point in time.

    At any given time, a built-in topic DDS.DataReader may store fragments for up to max_fragmented_samples samples while waiting for the remaining fragments. These samples need not have consecutive sequence numbers and may have been sent by different built-in topic DDS.DataWriter instances.

    Once all fragments of a sample have been received, the sample is treated as a regular sample and becomes subject to standard QoS settings such as DDS.BuiltinTopicReaderResourceLimits_t.max_samples.

    The middleware will drop fragments if the max_fragmented_samples limit has been reached. For best-effort communication, the middleware will accept a fragment for a new sample, but drop the oldest fragmented sample from the same remote writer. For reliable communication, the middleware will drop fragments for any new samples until all fragments for at least one older sample from that writer have been received.

    Only applies if DDS.BuiltinTopicReaderResourceLimits_t.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 1024

    [range] [1, 1 million]

    Initial_Fragmented_Samples: The initial number of samples for which a built-in topic DDS.DataReader may store fragments.

    Only applies if DDS.BuiltinTopicReaderResourceLimits_t.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 4

    [range] [1,1024], <= max_fragmented_samples

    Max_Fragmented_Samples_Per_Remote_Writer: The maximum number of samples per remote writer for which a built-in topic DDS.DataReader may store fragments.

    Logical limit so a single remote writer cannot consume all available resources.

    Only applies if DDS.BuiltinTopicReaderResourceLimits_t.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] 256

    [range] [1, 1 million], <= max_fragmented_samples

    Max_Fragments_Per_Sample: Maximum number of fragments for a single sample.

    Only applies if DDS.BuiltinTopicReaderResourceLimits_t.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1, 1 million] or DDS.LENGTH_UNLIMITED

    Dynamically_allocate_Fragmented_Samples: Determines whether the built-in topic DDS.DataReader pre-allocates storage for storing fragmented samples.

    By default, the middleware does not allocate memory upfront, but instead allocates memory from the heap upon receiving the first fragment of a new sample. The amount of memory allocated equals the amount of memory needed to store all fragments in the sample. Once all fragments of a sample have been received, the sample is deserialized and stored in the regular receive queue. At that time, the dynamically allocated memory is freed again.

    This QoS setting is useful for large, but variable-sized data types where upfront memory allocation for multiple samples based on the maximum possible sample size may be expensive. The main disadvantage of not pre-allocating memory is that one can no longer guarantee the middleware will have sufficient resources at run-time.

    If dynamically_allocate_fragmented_samples is set to DDS.BOOLEAN_FALSE, the middleware will allocate memory upfront for storing fragments for up to DDS.DataReaderResourceLimitsQosPolicy.initial_fragmented_samples samples. This memory may grow up to DDS.DataReaderResourceLimitsQosPolicy.max_fragmented_samples if needed.

    Only applies if DDS.DataReaderResourceLimitsQosPolicy.disable_fragmentation_support is DDS.BOOLEAN_FALSE.

    [default] DDS.BOOLEAN_TRUE

    BuiltinTopicKey_Array_T

    type  BuiltinTopicKey_Array_T is array
         (0 .. BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH - 1) of Builtin_Topic_Key_Type_Native;

    BuiltinTopicKey_T

    type BuiltinTopicKey_T is record
          Value : BuiltinTopicKey_Array_T := (others => 0);
       end record with Convention => C;

    Summary: The key type of the built-in topic types.

    Each remote DDS.Entity to be discovered can be uniquely identified by this key. This is the key of all the built-in topic data types.


    See also: DDS.ParticipantBuiltinTopicData
    See also: DDS.TopicBuiltinTopicData
    See also: DDS.PublicationBuiltinTopicData
    See also: DDS.SubscriptionBuiltinTopicData

    Value: An array of four integers that uniquely represents a remote DDS.Entity.

    BuiltinTopicKey_T_Access

    type BuiltinTopicKey_T_Access is access all BuiltinTopicKey_T;

    PublishModeQosPolicyKind

    type PublishModeQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of publishing mode

    QoS:
    DDS.PublishModeQosPolicy

    PublishModeQosPolicy

    type PublishModeQosPolicy is record
          Kind                 : aliased PublishModeQosPolicyKind := SYNCHRONOUS_PUBLISH_MODE_QOS;
          Flow_Controller_Name : aliased DDS.String;
          Priority             : aliased Long := PUBLICATION_PRIORITY_UNDEFINED;
       end record with Convention => C;

    Summary: Specifies how RTI Connext sends application data on the network. This QoS policy can be used to tell RTI Connext to use its own thread to send data, instead of the user thread.

    The publishing mode of a DDS.DataWriter determines whether data is written synchronously in the context of the user thread when calling FooDataWriter.write or asynchronously in the context of a separate thread internal to the middleware.

    Each DDS.Publisher spawns a single asynchronous publishing thread (DDS.AsynchronousPublisherQosPolicy.thread) to serve all its asynchronous DDS.DataWriter instances.


    See also: DDS.AsynchronousPublisherQosPolicy
    See also: DDS.HistoryQosPolicy
    See also: DDS.FlowController

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    The fastest way for RTI Connext to send data is for the user thread to execute the middleware code that actually sends the data itself. However, there are times when user applications may need or want an internal middleware thread to send the data instead. For instance, to send large data reliably, you must use an asynchronous thread.

    When data is written asynchronously, a DDS.FlowController, identified by flow_controller_name, can be used to shape the network traffic. Shaping a data flow usually means limiting the maximum data rates at which the middleware will send data for a DDS.DataWriter. The flow controller will buffer any excess data and only send it when the send rate drops below the maximum rate. The flow controller's properties determine when the asynchronous publishing thread is allowed to send data and how much.

    Asynchronous publishing may increase latency, but offers the following advantages:

    - The FooDataWriter.write call does not make any network calls and is therefore faster and more deterministic. This becomes important when the user thread is executing time-critical code.

    - When data is written in bursts or when sending large data types as multiple fragments, a flow controller can throttle the send rate of the asynchronous publishing thread to avoid flooding the network.

    - Asynchronously written samples for the same destination will be coalesced into a single network packet which reduces bandwidth consumption.

    The maximum number of samples that will be coalesced depends on NDDS_Transport_Property_t.gather_send_buffer_count_max (each sample requires at least 2-4 gather-send buffers). Performance can be improved by increasing NDDS_Transport_Property_t.gather_send_buffer_count_max. Note that the maximum value is operating system dependent.

    The middleware must queue samples until they can be sent by the asynchronous publishing thread (as determined by the corresponding DDS.FlowController). The number of samples that will be queued is determined by the DDS.HistoryQosPolicy. When using DDS.KEEP_LAST_HISTORY_QOS, only the most recent DDS.HistoryQosPolicy.depth samples are kept in the queue. Once unsent samples are removed from the queue, they are no longer available to the asynchronous publishing thread and will therefore never be sent.

    Kind: Publishing mode

    [default] DDS.SYNCHRONOUS_PUBLISH_MODE_QOS

    Flow_Controller_Name: Name of the associated flow controller

    NULL value or zero-length string refers to DDS.DEFAULT_FLOW_CONTROLLER_NAME.


    See also: DDS.DomainParticipant.create_flowcontroller
    See also: DDS.DEFAULT_FLOW_CONTROLLER_NAME
    See also: DDS.FIXED_RATE_FLOW_CONTROLLER_NAME
    See also: DDS.ON_DEMAND_FLOW_CONTROLLER_NAME

    [default] DDS.DEFAULT_FLOW_CONTROLLER_NAME

    Priority: Publication priority

    A positive integer value designating the relative priority of the DDS.DataWriter, used to determine the transmission order of pending writes.

    Use of publication priorities requires the asynchronous publisher (DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS) with DDS.FlowControllerProperty_t.scheduling_policy set to DDS.HPF_FLOW_CONTROLLER_SCHED_POLICY.

    Larger numbers have higher priority.

    For multi-channel DataWriters, if the publication priority of any channel is set to any value other than DDS.PUBLICATION_PRIORITY_UNDEFINED, then the channel's priority will take precedence over that of the DataWriter.

    For multi-channel DataWriters, if the publication priority of any channel is DDS.PUBLICATION_PRIORITY_UNDEFINED, then the channel will inherit the publication priority of the DataWriter.

    If the publicaton priority of the DataWriter, and of any channel of a multi-channel DataWriter, are DDS.PUBLICATION_PRIORITY_UNDEFINED, then the priority of the DataWriter or DataWriter channel will be assigned the lowest priority value.

    If the publication priority of the DataWriter is DDS.PUBLICATION_PRIORITY_AUTOMATIC, then the DataWriter will be assigned the priority of the largest publication priority of all samples in the DataWriter.

    The publication priority of each sample can be set in the DDS_WriteParams_t of the FooDataWriter.write_w_params function.

    For dispose and unregister samples, use the DDS_WriteParams_t of FooDataWriter.dispose_w_params and FooDataWriter.unregister_instance_w_params.

    [default] DDS.PUBLICATION_PRIORITY_UNDEFINED

    DiscoveryConfigBuiltinPluginKind

    type DiscoveryConfigBuiltinPluginKind is new DDS.Unsigned_Long;

    Summary: Built-in discovery plugins that can be used.


    See also: DDS.DiscoveryConfigBuiltinPluginKindMask

    DiscoveryConfigBuiltinPluginKindMask

    subtype DiscoveryConfigBuiltinPluginKindMask is  DiscoveryConfigBuiltinPluginKind;

    Summary: A bit-mask (list) of built-in discovery plugins.

    The bit-mask is an efficient and compact representation of a fixed-length list of DDS.DiscoveryConfigBuiltinPluginKind values.

    QoS:
    DDS.DiscoveryConfigQosPolicy

    DiscoveryPluginPromiscuityKind

    type DiscoveryPluginPromiscuityKind is new Unsigned_Long;

    RemoteParticipantPurgeKind

    type RemoteParticipantPurgeKind is new Unsigned_Long;

    Summary: Available behaviors for halting communication with remote participants (and their contained entities) with which discovery communication has been lost.

    When discovery communication with a remote participant has been lost, the local participant must make a decision about whether to continue attempting to communicate with that participant and its contained entities. This "kind" is used to select the desired behavior.

    This "kind" does not pertain to the situation in which a remote participant has been gracefully deleted and notification of that deletion have been successfully received by its peers. In that case, the local participant will immediately stop attempting to communicate with those entities and will remove the associated remote entity records from its internal database.


    See also: DDS.DiscoveryConfigQosPolicy.remote_participant_purge_kind

    DiscoveryBuiltinReaderFragmentationResourceLimits_T

    type DiscoveryBuiltinReaderFragmentationResourceLimits_T is record
          Disable_Fragmentation_Support            : aliased DDS.Boolean := False;
          Max_Fragmented_Samples                   : aliased Long := 1024;
          Initial_Fragmented_Samples               : aliased Long := 4;
          Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 256;
          Max_Fragments_Per_Sample                 : aliased Long := 512;
          Dynamically_Allocate_Fragmented_Samples  : aliased DDS.Boolean := False;
       end record with Convention => C;

    CdrPaddingKind

    type CdrPaddingKind is
         (ZERO_CDR_PADDING,
          NOT_SET_CDR_PADDING,
          AUTO_CDR_PADDING);

    TypeSupportQosPolicy

    type TypeSupportQosPolicy is record
          Plugin_Data      : aliased DDS_Support.Void_Ptr;
          Cdr_Padding_Kind : aliased CdrPaddingKind;
       end record with Convention => C;

    Summary: Allows you to attach application-specific values to a DDS.DataWriter or DDS.DataReader, which are passed to the serialization or deserialization routine of the associated data type and choose whether to set padding bytes to zero during serialization.

    The purpose of this QoS is to allow a user application to pass data to a type plugin's support functions and choose whether or not to set the padding bytes to zero when serializing a sample using CDR encapsulation.

    Entity:
    DDS.DomainParticipant, DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = NO

    "Changeable" = "UNTIL ENABLE"

    Usage

    The DDS.TypeSupportQosPolicy.plugin_data allows you to associate a pointer to an object with a DDS.DataWriter or DDS.DataReader. This object pointer is passed to the serialization routine of the data type associated with the DDS.DataWriter or the deserialization routine of the data type associated with the DDS.DataReader.

    You can modify the rtiddsgen-generated code so that the de/serialization routines act differently depending on the information passed in via the object pointer. (The generated serialization and deserialization code does not use the pointer.)

    This functionality can be used to change how data sent by a DDS.DataWriter or received by a DDS.DataReader is serialized or deserialized on a per DataWriter and DataReader basis.

    It can also be used to dynamically change how serialization (or for a less common case, deserialization) occurs. For example, a data type could represent a table, including the names of the rows and columns. However, since the row/column names of an instance of the table (a Topic) don't change, they only need to be sent once. The information passed in through the TypeSupport QoS policy could be used to signal the serialization routine to send the row/column names the first time a DDS.DataWriter calls FooDataWriter.write, and then never again.

    The DDS.TypeSupportQosPolicy.cdr_padding_kind allows you to choose whether or not the padding bytes are set to zero during CDR serialization.

    Plugin_Data: Value to pass into the type plugin's de-/serialization function

    [default] NULL

    cdr_padding_kind: Determines whether or not the padding bytes will be set to zero during CDR serialization.

    In a DomainParticipant, this value configures how the padding bytes are set when serializing data for the Built-In Topic DataWriters and DataReaders. A value of DDS.AUTO_CDR_PADDING defaults to DDS.NOT_SET_CDR_PADDING.

    For DataWriters and DataReaders, this value configures how padding bytes are set when serializing data for that entity. A value of DDS.AUTO_CDR_PADDING means that the entity will inherit whatever value is set on the DomainParticipant.

    [default] DDS.AUTO_CDR_PADDING

    ThreadBlockingKind

    type ThreadBlockingKind is new Unsigned_Long;

    AsynchronousPublisherQosPolicy

    type AsynchronousPublisherQosPolicy is record
          Disable_Asynchronous_Write       : aliased DDS.Boolean := False;
          Thread                           : aliased ThreadSettings_T;
          Disable_Asynchronous_Batch       : aliased Boolean  := False;
          Asynchronous_Batch_Thread        : aliased ThreadSettings_T;
          Asynchronous_Batch_Blocking_Kind : aliased ThreadBlockingKind := 0;
          Disable_Topic_Query_Publication  : aliased DDS.Boolean := False;
          Topic_Query_Publication_Thread   : aliased ThreadSettings_T;
       end record with Convention => C;

    Summary: Configures the mechanism that sends user data in an external middleware thread.

    Specifies the asynchronous publishing and asynchronous batch flushing settings of the DDS.Publisher instances.

    The QoS policy specifies whether asynchronous publishing and asynchronous batch flushing are enabled for the DDS.DataWriter entities belonging to this DDS.Publisher. If so, the publisher will spawn up to two threads, one for asynchronous publishing and one for asynchronous batch flushing.

    This policy also configures the settings of the DDS.TopicQuery publication thread. The publisher will spawn this thread only if one or more DataWriters enable TopicQueries.


    See also: DDS.BatchQosPolicy.
    See also: DDS.PublishModeQosPolicy.

    Entity:
    DDS.Publisher

    Properties:
    "Rx0" = N/A

    "Changeable" = "NO"

    Usage

    You can use this QoS policy to reduce the amount of time your application thread spends sending data.

    You can also use it, along with DDS.PublishModeQosPolicy and a DDS.FlowController, to send large data reliably. "Large" in this context means that the data that cannot be sent as a single packet by a network transport. For example, to send data larger than 63K reliably using UDP/IP, you must configure RTI Connext to fragment the data and send it asynchronously.

    The asynchronous publisher thread is shared by all DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS DDS.DataWriter instances that belong to this publisher and handles their data transmission chores.

    The asynchronous batch flushing thread is shared by all DDS.DataWriter instances with batching enabled that belong to this publisher.

    This QoS policy also allows you to adjust the settings of the asynchronous publishing and the asynchronous batch flushing threads. To use different threads for two different DDS.DataWriter entities, the instances must belong to different DDS.Publisher instances.

    A DDS.Publisher must have asynchronous publishing enabled for its DDS.DataWriter instances to write asynchronously.

    A DDS.Publisher must have asynchronous batch flushing enabled in order to flush the batches of its DDS.DataWriter instances asynchronously. However, no asynchronous batch flushing thread will be started until the first DDS.DataWriter instance with batching enabled is created from this DDS.Publisher.

    Disable_Asynchronous_Write: Disable asynchronous publishing.

    If set to DDS.BOOLEAN_TRUE, any DDS.DataWriter created with DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS will fail with DDS.RETCODE_INCONSISTENT_POLICY.

    [default] DDS.BOOLEAN_FALSE

    Thread: Settings of the publishing thread.

    There is only one asynchronous publishing thread per DDS.Publisher.

    [default] priority below normal.
    The actual value depends on your architecture:

    For Windows: -2
    For Linux: OS default priority
    For a complete list of platform specific values, please refer to Platform Notes .

    [default] The actual value depends on your architecture:

    For Windows: OS default stack size
    For Linux: OS default stack size
    For a complete list of platform specific values, please refer to ef_url_platform_notes.

    [default] mask = DDS.THREAD_SETTINGS_KIND_MASK_DEFAULT

    disable_asynchronous_batch: Disable asynchronous batch flushing.

    If set to DDS.BOOLEAN_TRUE, any DDS.DataWriter created with batching enabled will fail with DDS.RETCODE_INCONSISTENT_POLICY.

    If DDS.BatchQosPolicy.max_flush_delay is different than DDS_DURATION_INFINITE, DDS.AsynchronousPublisherQosPolicy.disable_asynchronous_batch must be set DDS.BOOLEAN_FALSE.

    [default] DDS.BOOLEAN_FALSE

    DiscoveryConfigQosPolicy

    type DiscoveryConfigQosPolicy is record
          Participant_Liveliness_Lease_Duration                  : aliased Duration_T := (100, 0);
          Participant_Liveliness_Assert_Period                   : aliased Duration_T := (30, 0);
          Remote_Participant_Purge_Kind                          : aliased RemoteParticipantPurgeKind := LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE;
          Max_Liveliness_Loss_Detection_Period                   : aliased Duration_T := (60, 0);
          Initial_Participant_Announcements                      : aliased Long := 5;
          Min_Initial_Participant_Announcement_Period            : aliased Duration_T := (1, 0);
          Max_Initial_Participant_Announcement_Period            : aliased Duration_T := (1, 0);
          Participant_Reader_Resource_Limits                     : aliased BuiltinTopicReaderResourceLimits_T := BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT;
          Publication_Reader                                     : aliased RtpsReliableReaderProtocol_T := RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT;
          Publication_Reader_Resource_Limits                     : aliased BuiltinTopicReaderResourceLimits_T;
          Subscription_Reader                                    : aliased RtpsReliableReaderProtocol_T;
          Subscription_Reader_Resource_Limits                    : aliased BuiltinTopicReaderResourceLimits_T;
          Publication_Writer                                     : aliased RtpsReliableWriterProtocol_T;
          Publication_Writer_Data_Lifecycle                      : aliased WriterDataLifecycleQosPolicy;
          Subscription_Writer                                    : aliased RtpsReliableWriterProtocol_T;
          Subscription_Writer_Data_Lifecycle                     : aliased WriterDataLifecycleQosPolicy;
          Endpoint_Plugin_Redundancy_Level                       : aliased Long;
          Builtin_Discovery_Plugins                              : aliased DiscoveryConfigBuiltinPluginKindMask;
          Participant_Message_Reader_Reliability_Kind            : aliased ReliabilityQosPolicyKind;
          Participant_Message_Reader                             : aliased RtpsReliableReaderProtocol_T;
          Participant_Message_Writer                             : aliased RtpsReliableWriterProtocol_T;
          Publication_Writer_Publish_Mode                        : aliased PublishModeQosPolicy;
          Subscription_Writer_Publish_Mode                       : aliased PublishModeQosPolicy;
          Asynchronous_Publisher                                 : aliased AsynchronousPublisherQosPolicy;
          Default_Domain_Announcement_Period                     : aliased Duration_T;
          Ignore_Default_Domain_Announcements                    : aliased Boolean;
          Service_Request_Writer                                 : aliased RtpsReliableWriterProtocol_T;
          Service_Request_Writer_Data_Lifecycle                  : aliased WriterDataLifecycleQosPolicy;
          Service_Request_Writer_Publish_Mode                    : aliased PublishModeQosPolicy;
          Service_Request_Reader                                 : aliased RtpsReliableReaderProtocol_T;
          Locator_Reachability_Assert_Period                     : aliased Duration_T;
          Locator_Reachability_Lease_Duration                    : aliased Duration_T;
          Locator_Reachability_Change_Detection_Period           : aliased Duration_T;
          --- <>
          Sedp_Rely_On_Spdp_Only                                 : aliased Boolean;
          Publication_Writer_Latency_Budget                      : aliased LatencyBudgetQosPolicy;
          Publication_Writer_Push_On_Write                       : aliased Boolean;
          Subscription_Writer_Latency_Budget                     : aliased LatencyBudgetQosPolicy;
          Subscription_Writer_Push_On_Write                      : aliased Boolean;
          Participant_State_Writer                               : aliased RtpsReliableWriterProtocol_T;
          Participant_State_Writer_Latency_Budget                : aliased LatencyBudgetQosPolicy;
          Participant_State_Writer_Push_On_Write                 : aliased Boolean;
          Participant_State_Writer_Publish_Mode                  : aliased PublishModeQosPolicy;
          Participant_Proxy_Reader                               : aliased RtpsReliableReaderProtocol_T;
          Participant_Proxy_Reader_Fragmentation_Resource_Limits : aliased DiscoveryBuiltinReaderFragmentationResourceLimits_T;
          Plugin_Promiscuity_Kind                                : aliased DiscoveryPluginPromiscuityKind;
       end record with Convention => C;

    Summary: Settings for discovery configuration.

    <<ext>> This QoS policy controls the amount of delay in discovering entities in the system and the amount of discovery traffic in the network.

    The amount of network traffic required by the discovery process can vary widely, based on how your application has chosen to configure the middleware's network addressing (e.g., unicast vs. multicast, multicast TTL, etc.), the size of the system, whether all applications are started at the same time or whether start times are staggered, and other factors. Your application can use this policy to make tradeoffs between discovery completion time and network bandwidth utilization. In addition, you can introduce random back-off periods into the discovery process to decrease the probability of network contention when many applications start simultaneously.

    Entity:
    DDS.DomainParticipant

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    participant_liveliness_lease_duration: The liveliness lease duration for the participant.

    This is the same as the expiration time of the DomainParticipant as defined in the RTPS protocol.

    If the participant has not refreshed its own liveliness to other participants at least once within this period, it may be considered as stale by other participants in the network.

    Should be strictly greater than DDS.DiscoveryConfigQosPolicy.participant_liveliness_assert_period.

    [default] 100 seconds

    [range] [1 nanosec,1 year], > participant_liveliness_assert_period

    participant_liveliness_assert_period: The period to assert liveliness for the participant.

    The period at which the participant will refresh its liveliness to all the peers.

    Should be strictly less than DDS.DiscoveryConfigQosPolicy.participant_liveliness_lease_duration.

    [default] 30 seconds

    [range] [1 nanosec,1 year), < participant_liveliness_lease_duration

    remote_participant_purge_kind: The participant's behavior for maintaining knowledge of remote participants (and their contained entities) with which discovery communication has been lost.

    Most users will not need to change this value from its default, DDS.LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE. However, DDS.NO_REMOTE_PARTICIPANT_PURGE may be a good choice if the following conditions apply:

    1. Discovery communication with a remote participant may be lost while data communication remains intact. Such will not typically be the case if discovery takes place over the Simple Discovery Protocol, but may be the case if the RTI Enterprise Discovery Service is used.
    2. Extensive and prolonged lack of discovery communication between participants is not expected to be common, either because participant loss itself is expected to be rare, or because participants may be lost sporadically but will typically return again.
    3. Maintaining inter-participant liveliness is problematic, perhaps because a participant has no writers with the appropriate DDS.LivelinessQosPolicyKind.

    [default] DDS.LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE

    max_liveliness_loss_detection_period: The maximum amount of time between when a remote entity stops maintaining its liveliness and when the matched local entity realizes that fact.

    Notification of the loss of liveliness of a remote entity may come more quickly that this duration, depending on the liveliness contract between the local and remote entities and the capabilities of the discovery mechanism in use. For example, a DDS.DataReader will learn of the loss of liveliness of a matched DDS.DataWriter within the reader's offered liveliness lease duration.

    Shortening this duration will increase the responsiveness of entities to communication failures. However, it will also increase the CPU usage of the application, as the liveliness of remote entities will be examined more frequently.

    [default] 60 seconds

    [range] [0, 1 year]

    initial_participant_announcements: The number of initial announcements sent when a participant is first enabled or when a remote participant is newly discovered.

    Also, when a new remote participant appears, the local participant can announce itself to the peers multiple times controlled by this parameter.

    [default] 5

    [range] [0,1 million]

    min_initial_participant_announcement_period: The minimum period between initial announcements when a participant is first enabled or when a remote participant is newly discovered.

    A random delay between this and DDS.DiscoveryConfigQosPolicy.max_initial_participant_announcement_period is introduced in between initial announcements when a new remote participant is discovered.

    The setting of DDS.DiscoveryConfigQosPolicy.min_initial_participant_announcement_period must be consistent with DDS.DiscoveryConfigQosPolicy.max_initial_participant_announcement_period. For these two values to be consistent, they must verify that:

    DDS.DiscoveryConfigQosPolicy.min_initial_participant_announcement_period <= DDS.DiscoveryConfigQosPolicy.max_initial_participant_announcement_period.

    [default] 1 second

    [range] [1 nanosec,1 year]

    max_initial_participant_announcement_period: The maximum period between initial announcements when a participant is first enabled or when a remote participant is newly discovered.

    A random delay between DDS.DiscoveryConfigQosPolicy.min_initial_participant_announcement_period and this is introduced in between initial announcements when a new remote participant is discovered.

    The setting of DDS.DiscoveryConfigQosPolicy.max_initial_participant_announcement_period must be consistent with DDS.DiscoveryConfigQosPolicy.min_initial_participant_announcement_period. For these two values to be consistent, they must verify that:

    DDS.DiscoveryConfigQosPolicy.min_initial_participant_announcement_period <= DDS.DiscoveryConfigQosPolicy.max_initial_participant_announcement_period.

    [default] 1 second

    [range] [1 nanosec,1 year]

    participant_reader_resource_limits: Resource limits.

    Resource limit of the built-in topic participant reader. For details, see DDS.BuiltinTopicReaderResourceLimits_t.

    publication_reader: RTPS protocol-related configuration settings for the RTPS reliable reader associated to a built-in publication reader.

    For details, refer to the DDS.RtpsReliableReaderProtocol_t

    [default]
    min_heartbeat_response_delay 0.0 seconds;
    max_heartbeat_response_delay 0.0 seconds;
    heartbeat_suppression_duration 0.0625 seconds;
    nack_period 5.0 seconds;
    receive_window_size 256;
    round_trip_time 0.0 seconds;
    app_ack_period 5.0 seconds;
    samples_per_app_ack 1;

    publication_reader_resource_limits: Resource limits.

    Resource limit of the built-in topic publication reader. For details, see DDS.BuiltinTopicReaderResourceLimits_t.

    subscription_reader: RTPS protocol-related configuration settings for the RTPS reliable reader associated to a built-in subscription reader.

    For details, refer to the DDS.RtpsReliableReaderProtocol_t

    [default]
    min_heartbeat_response_delay 0.0 seconds;
    max_heartbeat_response_delay 0.0 seconds;
    heartbeat_suppression_duration 0.0625 seconds;
    nack_period 5.0 seconds;
    receive_window_size 256;
    round_trip_time 0.0 seconds;
    app_ack_period 5.0 seconds;
    samples_per_app_ack 1;

    subscription_reader_resource_limits: Resource limits.

    Resource limit of the built-in topic subscription reader. For details, see DDS.BuiltinTopicReaderResourceLimits_t.

    publication_writer: RTPS protocol-related configuration settings for the RTPS reliable writer associated to a built-in publication writer.

    For details, refer to the DDS.RtpsReliableWriterProtocol_t

    [default]
    low_watermark 0;
    high_watermark 1;
    heartbeat_period 3.0 seconds;
    fast_heartbeat_period 3.0 seconds;
    late_joiner_heartbeat_period 3.0 seconds;
    virtual_heartbeat_period DDS_DURATION_INFINITE;
    samples_per_virtual_heartbeat DDS.LENGTH_UNLIMITED;
    max_heartbeat_retries 10;
    inactivate_nonprogressing_readers DDS.BOOLEAN_FALSE;
    heartbeats_per_max_samples 8;
    min_nack_response_delay 0.0 seconds;
    max_nack_response_delay 0.0 seconds;
    nack_suppression_duration 0.0 seconds;
    max_bytes_per_nack_response 131072 bytes;
    disable_positive_acks_min_sample_keep_duration 1.0 milliseconds;
    disable_positive_acks_max_sample_keep_duration 1.0 seconds;
    disable_positive_acks_enable_adaptive_sample_keep_duration DDS.BOOLEAN_TRUE;
    disable_positive_acks_decrease_sample_keep_duration_factor 95;
    disable_positive_acks_increase_sample_keep_duration_factor 150;
    min_send_window_size DDS.LENGTH_UNLIMITED;
    max_send_window_size DDS.LENGTH_UNLIMITED;
    send_window_update_period 3s;
    send_window_increase_factor 105;
    send_window_decrease_factor 50;
    enable_multicast_periodic_heartbeat DDS.BOOLEAN_FALSE;
    multicast_resend_threshold 2 readers;

    publication_writer_data_lifecycle: Writer data lifecycle settings for a built-in publication writer.

    For details, refer to the DDS.WriterDataLifecycleQosPolicy. DDS.WriterDataLifecycleQosPolicy.autodispose_unregistered_instances will always be forced to DDS.BOOLEAN_TRUE.

    subscription_writer: RTPS protocol-related configuration settings for the RTPS reliable writer associated to a built-in subscription writer.

    For details, refer to the DDS.RtpsReliableWriterProtocol_t

    [default]
    low_watermark 0;
    high_watermark 1;
    heartbeat_period 3.0 seconds;
    fast_heartbeat_period 3.0 seconds;
    late_joiner_heartbeat_period 3.0 seconds;
    virtual_heartbeat_period DDS_DURATION_INFINITE;
    samples_per_virtual_heartbeat DDS.LENGTH_UNLIMITED;
    max_heartbeat_retries 10;
    inactivate_nonprogressing_readers DDS.BOOLEAN_FALSE;
    heartbeats_per_max_samples 8;
    min_nack_response_delay 0.0 seconds;
    max_nack_response_delay 0.0 seconds;
    nack_suppression_duration 0.0 seconds;
    max_bytes_per_nack_response 131072 bytes;
    disable_positive_acks_min_sample_keep_duration 1.0 milliseconds;
    disable_positive_acks_max_sample_keep_duration 1.0 seconds;
    disable_positive_acks_enable_adaptive_sample_keep_duration DDS.BOOLEAN_TRUE;
    disable_positive_acks_decrease_sample_keep_duration_factor 95;
    disable_positive_acks_increase_sample_keep_duration_factor 150;
    min_send_window_size DDS.LENGTH_UNLIMITED;
    max_send_window_size DDS.LENGTH_UNLIMITED;
    send_window_update_period 3s;
    send_window_increase_factor 105;
    send_window_decrease_factor 50;
    enable_multicast_periodic_heartbeat DDS.BOOLEAN_FALSE;
    multicast_resend_threshold 2 readers;

    subscription_writer_data_lifecycle: Writer data lifecycle settings for a built-in subscription writer.

    For details, refer to the DDS.WriterDataLifecycleQosPolicy. DDS.WriterDataLifecycleQosPolicy.autodispose_unregistered_instances will always be forced to DDS.BOOLEAN_TRUE.

    Builtin_Discovery_Plugins: The kind mask for built-in discovery plugins.

    There are several built-in discovery plugin. This mask enables the different plugins. Any plugin not enabled will not be created.

    [default] DDS.DISCOVERYCONFIG_BUILTIN_SDP

    Participant_Message_Reader_Reliability_Kind: Reliability policy for a built-in participant message reader.

    For details, refer to the DDS.ReliabilityQosPolicyKind.

    [default] DDS.BEST_EFFORT_RELIABILITY_QOS

    participant_message_reader: RTPS reliable reader protocol-related configuration settings for a built-in participant message reader. This parameter only has effect if DDS.DiscoveryConfigQosPolicy.participant_message_reader_reliability_kind is set to DDS.RELIABLE_RELIABILITY_QOS.

    For details, refer to the DDS.RtpsReliableReaderProtocol_t

    [default]
    min_heartbeat_response_delay 0.0 seconds;
    max_heartbeat_response_delay 0.0 seconds;
    heartbeat_suppression_duration 0.0625 seconds;
    nack_period 5.0 seconds;
    receive_window_size 256;
    round_trip_time 0.0 seconds;
    app_ack_period 5.0 seconds;
    samples_per_app_ack 1;

    participant_message_writer: RTPS protocol-related configuration settings for the RTPS reliable writer associated to the built-in participant message writer. This parameter only has effect if the matching participant message reader is configured with DDS.RELIABLE_RELIABILITY_QOS DDS.ReliabilityQosPolicyKind.

    For details, refer to the DDS.RtpsReliableWriterProtocol_t

    [default]
    low_watermark 0;
    high_watermark 1;
    heartbeat_period 1.0 seconds;
    fast_heartbeat_period 1.0 seconds;
    late_joiner_heartbeat_period 1.0 seconds;
    virtual_heartbeat_period DDS_DURATION_INFINITE;
    samples_per_virtual_heartbeat DDS.LENGTH_UNLIMITED;
    max_heartbeat_retries 10;
    inactivate_nonprogressing_readers DDS.BOOLEAN_FALSE;
    heartbeats_per_max_samples 1;
    min_nack_response_delay 0.0 seconds;
    max_nack_response_delay 0.0 seconds;
    nack_suppression_duration 0.0 seconds;
    max_bytes_per_nack_response 9216 bytes;
    disable_positive_acks_min_sample_keep_duration 1.0 milliseconds;
    disable_positive_acks_max_sample_keep_duration 1.0 seconds;
    disable_positive_acks_enable_adaptive_sample_keep_duration DDS.BOOLEAN_TRUE;
    disable_positive_acks_decrease_sample_keep_duration_factor 95;
    disable_positive_acks_increase_sample_keep_duration_factor 150;
    min_send_window_size DDS.LENGTH_UNLIMITED;
    max_send_window_size DDS.LENGTH_UNLIMITED;
    send_window_update_period 1s;
    send_window_increase_factor 105;
    send_window_decrease_factor 50;
    enable_multicast_periodic_heartbeat DDS.BOOLEAN_FALSE;
    multicast_resend_threshold 2 readers;

    Publication_Writer_Publish_Mode: Publish mode policy for the built-in publication writer.

    Determines whether the Discovery built-in publication DDS.DataWriter publishes data synchronously or asynchronously and how.

    Subscription_Writer_Publish_Mode: Publish mode policy for the built-in subscription writer.

    Determines whether the Discovery built-in subscription DDS.DataWriter publishes data synchronously or asynchronously and how.

    Asynchronous_Publisher: Asynchronous publishing settings for the discovery DDS.Publisher and all entities that are created by it.

    default_domain_announcement_period: The period to announce a participant to the default domain 0.

    The period at which a participant will announce itself to the default domain 0 using the default UDPv4 multicast group address for discovery traffic on that domain.

    For domain 0, the default discovery multicast address is 239.255.0.1:7400.

    To disable announcement to the default domain, set this period to DDS_DURATION_INFINITE.

    When this period is set to a value other than DDS_DURATION_INFINITE and DDS.DiscoveryConfigQosPolicy.ignore_default_domain_announcements is set to DDS.BOOLEAN_FALSE, you can get information about participants running in different domains by creating a participant in domain 0 and implementing the on_data_available callback in the DDS.ParticipantBuiltinTopicData built-in DataReader's listener.

    You can learn the domain ID associated with a participant by looking at the field DDS.ParticipantBuiltinTopicData.domain_id.

    [default] 30 seconds

    [range] [1 nanosec,1 year] or DDS_DURATION_INFINITE

    \see DDS.ParticipantBuiltinTopicData.domain_id \see DDS.DiscoveryConfigQosPolicy.ignore_default_domain_announcements

    ignore_default_domain_announcements: Used to ignore the announcements received by a participant on the default domain 0 corresponding to participants running on domains IDs other than 0.

    This setting only applies to participants running on the default domain 0 and using the default port mapping.

    When this setting is set to DDS.BOOLEAN_TRUE, a participant running on the default domain 0 will ignore announcements from participants running on different domain IDs.

    When this setting is set to DDS.BOOLEAN_FALSE, a participant running on the default domain 0 will provide announcements from participants running on different domain IDs to the application via the DDS.ParticipantBuiltinTopicData built-in DataReader.

    [default] DDS.BOOLEAN_TRUE

    \see DDS.ParticipantBuiltinTopicData.domain_id \see DDS.DiscoveryConfigQosPolicy.default_domain_announcement_period

    UserObjectQosPolicy

    type UserObjectQosPolicy is record
          Participant_User_Object            : aliased UserObjectSettings_T;
          Topic_User_Object                  : aliased UserObjectSettings_T;
          Content_Filtered_Topic_User_Object : aliased UserObjectSettings_T;
          Publisher_User_Object              : aliased UserObjectSettings_T;
          Data_Writer_User_Object            : aliased UserObjectSettings_T;
          Subscriber_User_Object             : aliased UserObjectSettings_T;
          Data_Reader_User_Object            : aliased UserObjectSettings_T;
          Read_Condition_User_Object         : aliased UserObjectSettings_T;
          Query_Condition_User_Object        : aliased UserObjectSettings_T;
          Index_Condition_User_Object        : aliased UserObjectSettings_T;
          Flow_Controller_User_Object        : aliased UserObjectSettings_T;
       end record with Convention => C;

    ExclusiveAreaQosPolicy

    type ExclusiveAreaQosPolicy is record
          Use_Shared_Exclusive_Area : aliased DDS.Boolean;
          Level                     : aliased DDS.Long;
       end record with Convention => C;

    Summary: Configures multi-thread concurrency and deadlock prevention capabilities.

    An "exclusive area" is an abstraction of a multi-thread-safe region. Each entity is protected by one and only one exclusive area, although a single exclusive area may be shared by multiple entities.

    Conceptually, an exclusive area is a mutex or monitor with additional deadlock protection features. If a DDS.Entity has "entered" its exclusive area to perform a protected operation, no other DDS.Entity sharing the same exclusive area may enter it until the first DDS.Entity "exits" the exclusive area.

    Entity:
    DDS.Publisher, DDS.Subscriber

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"


    See also: DDS.Listener

    Usage

    Exclusive Areas (EAs) allow RTI Connext to be multi-threaded while preventing deadlock in multi-threaded applications. EAs prevent a DDS.DomainParticipant object's internal threads from deadlocking with each other when executing internal code as well as when executing the code of user-registered listener callbacks.

    Within an EA, all calls to the code protected by the EA are single threaded. Each DDS.DomainParticipant, DDS.Publisher and DDS.Subscriber entity represents a separate EA. Thus all DataWriters of the same Publisher and all DataReaders of the same Subscriber share the EA of its parent. Note: this means that operations on the DataWriters of the same Publisher and on the DataReaders of the same Subscriber will be serialized, even when invoked from multiple concurrent application threads.

    Within an EA, there are limitations on how code protected by a different EA can be accessed. For example, when received data is being processed by user code in the DataReader Listener, within a Subscriber EA, the user code may call the FooDataWriter.write operation of a DataWriter that is protected by the EA of its Publisher, so you can send data in the function called to process received data. However, you cannot create entities or call functions that are protected by the EA of the DDS.DomainParticipant. See Chapter 4 in the User's Manual for complete documentation on Exclusive Areas.

    With this QoS policy, you can force a DDS.Publisher or DDS.Subscriber to share the same EA as its DDS.DomainParticipant. Using this capability, the restriction of not being able to create entities in a DataReader Listener's on_data_available() callback is lifted. However, the tradeoff is that the application has reduced concurrency through the Entities that share an EA.

    Note that the restrictions on calling methods in a different EA only exist for user code that is called in registered DDS Listeners by internal DomainParticipant threads. User code may call all RTI Connext functions for any DDS Entities from their own threads at any time.

    User_Shared_Exclusive_Area: Whether the DDS.Entity is protected by its own exclusive area or the shared exclusive area.

    All writers belonging to the same DDS.Publisher are protected by the same exclusive area as the DDS.Publisher itself. The same is true of all readers belonging to the same DDS.Subscriber. Typically, the publishers and subscribers themselves do not share their exclusive areas with each other; each has its own. This configuration maximizes the concurrency of the system because independent readers and writers do not need to take the same mutexes in order to operate. However, it places some restrictions on the operations that may be invoked from within listener callbacks because of the possibility of a deadlock. See the DDS.Listener documentation for more details.

    If this field is set to DDS.BOOLEAN_FALSE, the default more concurrent behavior will be used. In the event that this behavior is insufficiently flexible for your application, you may set this value to DDS.BOOLEAN_TRUE. In that case, the DDS.Subscriber or DDS.Publisher in question, and all of the readers or writers (as appropriate) created from it, will share a global exclusive area. This global exclusive area is shared by all entities whose value for this QoS field is DDS.BOOLEAN_TRUE. By sharing the same exclusive area across a larger number of entities, the concurrency of the system will be decreased; however, some of the callback restrictions will be relaxed.

    [default] DDS.BOOLEAN_FALSE

    \internal The setting for this field on a DDS.DomainParticipant overrides the setting on that participant's contained publishers and subscribers. In other words, if this field is set to DDS.BOOLEAN_TRUE on a participant, all entities of that participant will share the same exclusive area, effectively making all of the activity of those entities single-threaded, regardless of the settings on the individual publishers and subscribers. Needless to say, taking this step could seriously impact the performance of your application. It can be useful for debugging purposes but is not recommended in a production environment.

    TopicQueryDispatchQosPolicy

    type TopicQueryDispatchQosPolicy is record
          Enable                      : aliased DDS.Boolean;
          Publication_period          : aliased Duration_T;
          Samples_Per_Period          : aliased DDS.Long;
       end record with Convention => C;
    TODO: Add Docs

    BatchQosPolicy

    type BatchQosPolicy is record
          Enable                      : aliased DDS.Boolean;
          Max_Data_Bytes              : aliased DDS.Long;
          Max_Meta_Data_Bytes         : aliased DDS.Long;
          Max_Samples                 : aliased DDS.Long;
          Max_Flush_Delay             : aliased Duration_T;
          Source_Timestamp_Resolution : aliased Duration_T;
          Thread_Safe_Write           : aliased DDS.Boolean;
       end record with Convention => C;

    Summary: Used to configure batching of multiple samples into a single network packet in order to increase throughput for small samples.

    This QoS policy configures the ability of the middleware to collect multiple user data samples to be sent in a single network packet, to take advantage of the efficiency of sending larger packets and thus increase effective throughput.

    This QoS policy can be used to dramatically increase effective throughput for small data samples. Usually, throughput for small samples (size < 2048 bytes) is limited by CPU capacity and not by network bandwidth. Batching many smaller samples to be sent in a single large packet will increase network utilization, and thus throughput, in terms of samples per second.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = NO
    "Changeable" = "UNTIL ENABLE"

    enable: Specifies whether or not batching is enabled.

    [default] DDS.BOOLEAN_FALSE

    max_data_bytes: The maximum cumulative length of all serialized samples in a batch.

    A batch is flushed automatically when this maximum is reached.

    max_data_bytes does not include the meta data associated with the batch samples. Each sample has at least 8 bytes of meta data containing information such as the timestamp and sequence number. The meta data can be as large as 52 bytes for keyed topics and 20 bytes for unkeyed topics.

    Note: Batches must contain whole samples. If a new batch is started and its initial sample causes the serialized size to exceed max_data_bytes, RTI Connext will send the sample in a single batch.

    [default] 1024

    [range] [1,DDS.LENGTH_UNLIMITED]

    Consistency

    The setting of DDS.BatchQosPolicy.max_data_bytes must be consistent with DDS.BatchQosPolicy.max_samples. For these two values to be consistent, they cannot be both DDS.LENGTH_UNLIMITED.

    max_samples: The maximum number of samples in a batch.

    A batch is flushed automatically when this maximum is reached.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,DDS.LENGTH_UNLIMITED]

    Consistency

    The setting of DDS.BatchQosPolicy.max_samples must be consistent with DDS.BatchQosPolicy.max_data_bytes. For these two values to be consistent, they cannot be both DDS.LENGTH_UNLIMITED.

    max_flush_delay: The maximum flush delay.

    A batch is flushed automatically after the delay specified by this parameter.

    The delay is measured from the time the first sample in the batch is written by the application.

    [default] DDS_DURATION_INFINITE

    [range] [0,DDS_DURATION_INFINITE]

    Consistency

    The setting of DDS.BatchQosPolicy.max_flush_delay must be consistent with DDS.AsynchronousPublisherQosPolicy.disable_asynchronous_batch and DDS.BatchQosPolicy.thread_safe_write. If the delay is different than DDS_DURATION_INFINITE, DDS.AsynchronousPublisherQosPolicy.disable_asynchronous_batch must be set to DDS.BOOLEAN_FALSE and DDS.BatchQosPolicy.thread_safe_write must be set to DDS.BOOLEAN_TRUE.

    source_timestamp_resolution: Batch source timestamp resolution.

    The value of this field determines how the source timestamp is associated with the samples in a batch.

    A sample written with timestamp 't' inherits the source timestamp 't2' associated with the previous sample unless ('t' - 't2') > source_timestamp_resolution.

    If source_timestamp_resolution is set to DDS_DURATION_INFINITE, every sample in the batch will share the source timestamp associated with the first sample.

    If source_timestamp_resolution is set to zero, every sample in the batch will contain its own source timestamp corresponding to the moment when the sample was written.

    The performance of the batching process is better when source_timestamp_resolution is set to DDS_DURATION_INFINITE.

    [default] DDS_DURATION_INFINITE

    [range] [0,DDS_DURATION_INFINITE]

    Consistency

    The setting of DDS.BatchQosPolicy.source_timestamp_resolution must be consistent with DDS.BatchQosPolicy.thread_safe_write. If DDS.BatchQosPolicy.thread_safe_write is set to DDS.BOOLEAN_FALSE, DDS.BatchQosPolicy.source_timestamp_resolution must be set to DDS_DURATION_INFINITE.

    thread_safe_write: Determines whether or not the write operation is thread safe.

    If this parameter is set to DDS.BOOLEAN_TRUE, multiple threads can call write on the DDS.DataWriter concurrently.

    [default] DDS.BOOLEAN_TRUE

    Consistency

    The setting of DDS.BatchQosPolicy.thread_safe_write must be consistent with DDS.BatchQosPolicy.source_timestamp_resolution. If DDS.BatchQosPolicy.thread_safe_write is set to DDS.BOOLEAN_FALSE, DDS.BatchQosPolicy.source_timestamp_resolution must be set to DDS_DURATION_INFINITE.

    TypeConsistencyKind

    type TypeConsistencyKind is new Unsigned_Long;

    Summary: Kinds of type consistency

    QoS:
    DDS.TypeConsistencyEnforcementQosPolicy

    TypeConsistencyEnforcementQosPolicy

    type TypeConsistencyEnforcementQosPolicy is record
          Kind                      : aliased TypeConsistencyKind;
       end record with Convention => C;

    Summary: Defines the rules for determining whether the type used to publish a given topic is consistent with that used to subscribe to it.

    This policy defines a type consistency kind, which allows applications to select from among a set of predetermined behaviors. The following consistency kinds are specified: DDS.DISALLOW_TYPE_COERCION and DDS.ALLOW_TYPE_COERCION.

    The type-consistency-enforcement rules consist of two steps:

    Step 1. If both the DataWriter and DataReader specify a TypeObject, it is considered first. If the DataReader allows type coercion, then its type must be assignable from the DataWriter's type. If the DataReader does not allow type coercion, then its type must be structurally identical to the type of the DataWriter.

    Step 2. If either the DataWriter or the DataReader does not provide a TypeObject definition, then the registered type names are examined. The DataReader's and DataWriter's registered type names must match exactly, as was true in RTI Connext releases prior to 5.0.0.

    If either Step 1 or Step 2 fails, the Topics associated with the DataReader and DataWriter are considered to be inconsistent and the DDS.InconsistentTopicStatus is updated.

    The default enforcement kind is DDS.ALLOW_TYPE_COERCION. However, when the middleware is introspecting the built-in topic data declaration of a remote DataReader in order to determine whether it can match with a local DataWriter, if it observes that no TypeConsistencyEnforcementQosPolicy value is provided (as would be the case when communicating with a Service implementation not in conformance with this specification), it assumes a kind of DDS.DISALLOW_TYPE_COERCION.

    For additional information on type consistency enforcement refer to the ef_url_xtypes_addendum and the ef_url_xtypes_spec.

    Entity:
    DDS.DataReader

    Properties:
    "Rx0" = N/A
    "Changeable" = "UNTIL ENABLE"

    kind: Type consistency kind.

    [default] DDS.ALLOW_TYPE_COERCION

    LocatorFilter_T

    type LocatorFilter_T is record
          Locators          : aliased Locator_Seq.Sequence;
          Filter_Expression : DDS.String;
       end record with Convention => C;

    Summary: Specifies the configuration of an individual channel within a MultiChannel DataWriter.

    QoS:
    DDS.LocatorFilterQosPolicy

    locators: Sequence containing from one to \locator_list_max_size DDS.Locator_t, used to specify the multicast address locators of an individual channel within a MultiChannel DataWriter.

    [default] Empty sequence.

    filter_expression: A logical expression used to determine the data that will be published in the channel.

    If the expression evaluates to TRUE, a sample will be published on the channel.

    An empty string always evaluates the expression to TRUE.

    \ifnot CPP2_LANGUAGE_ONLY A NULL value is not allowed.\endif

    The syntax of the expression will depend on the value of DDS.LocatorFilterQosPolicy.filter_name


    See also: DDSQueryAndFilterSyntaxModule

    [default] NULL (invalid value)

    LocatorFilter_T_Access

    type LocatorFilter_T_Access is access all LocatorFilter_T;

    LocatorFilter_T_Array

    type LocatorFilter_T_Array is array
         (Natural range <>) of aliased LocatorFilter_T;

    LocatorFilterQosPolicy

    type LocatorFilterQosPolicy is record
          Locator_Filters : aliased DDS.LocatorFilter_Seq.Sequence;
          Filter_Name     : aliased DDS.String;
       end record with Convention => C;

    Summary: The QoS policy used to report the configuration of a MultiChannel DataWriter as part of DDS.PublicationBuiltinTopicData.

    Entity:
    DDS.PublicationBuiltinTopicData

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    locator_filters: A sequence of DDS.LocatorFilter_t. Each DDS.LocatorFilter_t reports the configuration of a single channel of a MultiChannel DataWriter.

    A sequence length of zero indicates the DDS.MultiChannelQosPolicy is not in use.

    [default] Empty sequence.

    filer_name: Name of the filter class used to describe the filter expressions of a MultiChannel DataWriter.

    The following builtin filters are supported: DDS.SQLFILTER_NAME and DDS.STRINGMATCHFILTER_NAME.

    [default] DDS.STRINGMATCHFILTER_NAME

    ChannelSettings_T

    type ChannelSettings_T is record
          Multicast_Settings : aliased TransportMulticastSettings_Seq.Sequence;
          Filter_Expression  : DDS.String;
          Priority           : DDS.Long;
       end record with Convention => C;

    Summary: Type used to configure the properties of a channel.

    QoS:
    DDS.MultiChannelQosPolicy

    multicast_settings: A sequence of DDS.TransportMulticastSettings_t used to configure the multicast addresses associated with a channel.

    The sequence cannot be empty.

    The maximum number of multicast locators in a channel is limited to \locator_list_max_size (a locator is defined by a transport alias, a multicast address and a port). Note that this is a hard limit that cannot be increased. However, this limit can be decreased by configuring the 'dds.domain_participant.max_announced_locator_list_size' property in the DDS.PropertyQosPolicy associated with the DDS.DomainParticipantQos.

    [default] Empty sequence (invalid value)

    filter_expression: A logical expression used to determine the data that will be published in the channel.

    If the expression evaluates to TRUE, a sample will be published on the channel.

    An empty string always evaluates the expression to TRUE.

    \ifnot CPP2_LANGUAGE_ONLY A NULL value is not allowed.\endif

    The syntax of the expression will depend on the value of DDS.MultiChannelQosPolicy.filter_name

    The filter expression length (including NULL-terminated character) cannot be greater than DDS.DomainParticipantResourceLimitsQosPolicy.channel_filter_expression_max_length.


    See also: DDSQueryAndFilterSyntaxModule

    [default] NULL (invalid value)

    priority: Publication priority

    A positive integer value designating the relative priority of the channel, used to determine the transmission order of pending writes.

    Use of publication priorities requires the asynchronous publisher (DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS) with DDS.FlowControllerProperty_t.scheduling_policy set to DDS.HPF_FLOW_CONTROLLER_SCHED_POLICY.

    Larger numbers have higher priority.

    If the publication priority of the channel is any value other than DDS.PUBLICATION_PRIORITY_UNDEFINED, then the channel's priority will take precedence over the data writer's priority.

    If the publication priority of the channel is set to DDS.PUBLICATION_PRIORITY_UNDEFINED, then the channel's priority will be set to the value of the data writer's priority.

    If the publicaton priority of both the data writer and the channel are DDS.PUBLICATION_PRIORITY_UNDEFINED, the channel will be assigned the lowest priority value.

    If the publication priority of the channel is DDS.PUBLICATION_PRIORITY_AUTOMATIC, then the channel will be assigned the priority of the largest publication priority of all samples in the channel. The publication priority of each sample can be set in the DDS_WriteParams_t of the FooDataWriter.write_w_params function.

    [default] DDS.PUBLICATION_PRIORITY_UNDEFINED

    ChannelSettings_T_Access

    type ChannelSettings_T_Access is access all ChannelSettings_T;

    ChannelSettings_T_Array

    type ChannelSettings_T_Array is array
         (Natural range <>) of aliased ChannelSettings_T;

    MultiChannelQosPolicy

    type MultiChannelQosPolicy is record
          Channels    : aliased DDS.ChannelSettings_Seq.Sequence;
          Filter_Name : aliased DDS.String;
       end record with Convention => C;

    Summary: Configures the ability of a DataWriter to send data on different multicast groups (addresses) based on the value of the data.

    This QoS policy is used to partition the data published by a DDS.DataWriter across multiple channels. A channel is defined by a filter expression and a sequence of multicast locators.

    Entity:
    DDS.DataWriter

    Properties:
    "Rx0" = N/A
    "Changeable" = "NO"

    Usage

    By using this QoS, a DDS.DataWriter can be configured to send data to different multicast groups based on the content of the data. Using syntax similar to those used in Content-Based Filters, you can associate different multicast addresses with filter expressions that operate on the values of the fields within the data. When your application's code calls FooDataWriter.write, data is sent to any multicast address for which the data passes the filter.

    Multi-channel DataWriters can be used to trade off network bandwidth with the unnecessary processing of unwanted data for situations where there are multiple DataReaders that are interested in different subsets of data that come from the same data stream (Topic). For example, in Financial applications, the data stream may be quotes for different stocks at an exchange. Applications usually only want to receive data (quotes) for only a subset of the stocks being traded. In tracking applications, a data stream may carry information on hundreds or thousands of objects being tracked, but again, applications may only be interested in a subset.

    The problem is that the most efficient way to deliver data to multiple applications is to use multicast, so that a data value is only sent once on the network for any number of subscribers to the data. However, using multicast, an application will receive all of the data sent and not just the data in which it is interested, thus extra CPU time is wasted to throw away unwanted data. With this QoS, you can analyze the data-usage patterns of your applications and optimize network vs. CPU usage by partitioning the data into multiple multicast streams. While network bandwidth is still being conserved by sending data only once using multicast, most applications will only need to listen to a subset of the multicast addresses and receive a reduced amount of unwanted data.

    Your system can gain more of the benefits of using multiple multicast groups if your network uses Layer 2 Ethernet switches. Layer 2 switches can be configured to only route multicast packets to those ports that have added membership to specific multicast groups. Using those switches will ensure that only the multicast packets used by applications on a node are routed to the node; all others are filtered-out by the switch.

    channels: A sequence of DDS.ChannelSettings_t used to configure the channels' properties. If the length of the sequence is zero, the QoS policy will be ignored.

    A sequence length of zero indicates the DDS.MultiChannelQosPolicy is not in use.

    The sequence length cannot be greater than DDS.DomainParticipantResourceLimitsQosPolicy.channel_seq_max_length.

    [default] Empty sequence.

    filter_name: Name of the filter class used to describe the filter expressions of a MultiChannel DataWriter.

    The following builtin filters are supported: DDS.SQLFILTER_NAME and DDS.STRINGMATCHFILTER_NAME.

    [default] DDS.STRINGMATCHFILTER_NAME

    Property_T

    type Property_T is record
          Name      : aliased DDS.String;
          Value     : aliased DDS.String;
          Propagate : aliased DDS.Boolean;
       end record with Convention => C;

    Summary: Properties are name/value pairs objects.

    Name: Property name.

    Value: Property value.

    Propagate: Indicates if the property must be propagated on discovery.

    Property_T_Access

    type Property_T_Access is access all Property_T;

    Property_T_Array

    type Property_T_Array is array (Natural range <>) of aliased Property_T;

    Property_T_Seq_Access

    type Property_T_Seq_Access is access all Property_T_Seq.Sequence;

    PropertyQosPolicy

    type PropertyQosPolicy is record
          Value :  aliased Property_T_Seq.Sequence;
       end record with Convention => C;

    Summary: Stores name/value(string) pairs that can be used to configure certain parameters of RTI Connext that are not exposed through formal QoS policies. Can also be used to store and propagate application-specific name/value pairs that can be retrieved by user code during discovery.

    Entity:
    DDS.DomainParticipant DDS.DataReader DDS.DataWriter

    Properties:
    "Rx0" = N/A;
    "Changeable" = "YES"


    See also: DDS.DomainParticipant.get_builtin_subscriber

    Usage

    The PROPERTY QoS policy can be used to associate a set of properties in the form of (name,value) pairs with a DDS.DataReader, DDS.DataWriter, or DDS.DomainParticipant. This is similar to the DDS.UserDataQosPolicy, except this policy uses (name, value) pairs, and you can select whether or not a particular pair should be propagated (included in the builtin topic).

    This QoS policy may be used to configure:

  • Durable Writer History, see NDDSDurableWriterConfiguration

  • Durable Reader State, see NDDSDurableReaderConfiguration

  • Builtin Transport Plugins, see TransportUDPv4PropertyNameModule, TransportUDPv6PropertyNameModule, and TransportSHMEMPropertyNameModule

  • Extension Transport Plugins, see NDDSTransportLoadPluginModule

  • NDDSClockSelectionModule

    In addition, you may add your own name/value pairs to the Property QoS policy of an Entity. Via this QoS policy, you can direct RTI Connext to propagate these name/value pairs with the discovery information for the Entity. Applications that discover the Entity can then access the user-specific name/value pairs in the discovery information of the remote Entity. This allows you to add meta-information about an Entity for application-specific use, for example, authentication/authorization certificates (which can also be done using the DDS.UserDataQosPolicy or DDS.GroupDataQosPolicy).

    Reasons for Using the PropertyQosPolicy

  • Supports dynamic loading of extension transports (such as RTI Secure WAN Transport)

  • Supports multiple instances of the builtin transports

  • Allows full pluggable transport configuration for non-C/C++ language bindings (Java, .NET, etc.)

  • Avoids the process of creating entities disabled, changing their QoS settings, then enabling them

  • Allows selection of clock

    Some of the RTI Connext capabilities configurable via the Property QoS policy can also be configured in code via APIs. However, the Property QoS policy allows you to configure those parameters via XML files. In addition, some of the configuration APIs will only work if the Entity was created in a disabled state and then enabled after the configuration change was applied. By configuring those parameters using the Property QoS policy during entity creation, you avoid the additional work of first creating a disabled entity and then enabling it afterwards.

    There are helper functions to facilitate working with properties, see the DDSPropertyQosModule page.

    Value: Sequence of properties.

    [default] An empty list.

  • PropertyQosPolicy_Access

    type PropertyQosPolicy_Access is access all PropertyQosPolicy;

    WaitSetProperty_T

    type WaitSetProperty_T is record
          Max_Event_Count : aliased Interfaces.C.long; -- Use the same definition of long as in C
          Max_Event_Delay : aliased Duration_T;
       end record with Convention => C;

    Summary: <<ext>> Specifies the DDS.WaitSet behavior for multiple trigger events.

    In simple use, a DDS.WaitSet returns when a single trigger event occurs on one of its attached DDS.Condition (s), or when the timeout maximum wait duration specified in the DDS.WaitSet.wait call expires.

    The DDS.WaitSetProperty_t allows configuration of the waiting behavior of a DDS.WaitSet. If no conditions are true at the time of the call to wait, then the max_event_count parameter may be used to configure the WaitSet to wait for max_event_count trigger events to occur before returning, or to wait for up to max_event_delay time from the occurrence of the first trigger event before returning.

    The timeout maximum wait duration specified in the DDS.WaitSet.wait call continues to apply.

    Entity:
    DDS.WaitSet

    Properties:
    "Rx0" = N/A

    "Changeable" = "YES"

    max_event_count: Maximum number of trigger events to cause a DDS.WaitSet to awaken.

    The DDS.WaitSet will wait until up to max_event_count trigger events have occurred before returning. The DDS.WaitSet may return earlier if either the timeout duration has expired, or max_event_delay has elapsed since the occurrence of the first trigger event. max_event_count may be used to "collect" multiple trigger events for processing at the same time.

    [default] 1

    [range] >= 1

    max_event_delay: Maximum delay from occurrence of first trigger event to cause a DDS.WaitSet to awaken.

    The DDS.WaitSet will return no later than max_event_delay after the first trigger event. max_event_delay may be used to establish a maximum latency for events reported by the DDS.WaitSet.

    Note that DDS.RETCODE_TIMEOUT is not returned if max_event_delay is exceeded. DDS.RETCODE_TIMEOUT is returned only if the timeout duration expires before any trigger events occur.

    [default] DDS_DURATION_INFINITE

    EndpointGroup_T

    type EndpointGroup_T is record
          Role_Name    : aliased DDS.String;
          Quorum_Count : aliased Integer := 0;
       end record with Convention => C;

    Summary: Specifies a group of endpoints that can be collectively identified by a name and satisfied by a quorum.

    role_name: Defines the role name of the endpoint group.

    If used in the DDS.AvailabilityQosPolicy on a DDS.DataWriter, it specifies the name that identifies a Durable Subcription.

    quorum_count: Defines the minimum number of members that satisfies the endpoint group.

    If used in the DDS.AvailabilityQosPolicy on a DDS.DataWriter, it specifies the number of DataReaders that must acknowledge a sample before the sample is considered to be acknowledged by the Durable Subscription.

    EndpointGroup_T_Access

    type EndpointGroup_T_Access is access all EndpointGroup_T;

    EndpointGroup_T_Array

    type EndpointGroup_T_Array is array (Natural range <>) of aliased EndpointGroup_T;

    EndpointGroup_T_Seq_Access

    type EndpointGroup_T_Seq_Access is access all EndpointGroup_T_Seq.Sequence;

    AvailabilityQosPolicy

    type AvailabilityQosPolicy is record
          Enable_Required_Subscriptions          : aliased Boolean := False;
          Max_Data_Availability_Waiting_Time     : aliased Duration_T := (1, 0);
          Max_Endpoint_Availability_Waiting_Time : aliased Duration_T := (1, 0);
          Required_Matched_Endpoint_Groups       : aliased EndpointGroup_T_Seq.Sequence;
       end record with Convention => C;

    Summary: Configures the availability of data.

    Entity:
    DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = NO
    "Changeable" = "YES" (only on a DDS.DataWriter except for the member DDS.AvailabilityQosPolicy.enable_required_subscriptions)

    Usage

    This QoS policy is used in the context of two features:

  • Collaborative DataWriters
  • Required Subscriptions

    Collaborative DataWriters

    The Collaborative DataWriters feature allows having multiple DataWriters publishing samples from a common logical data source. The DataReaders will combine the samples coming from the DataWriters in order to reconstruct the correct order at the source.

    This QoS policy allows you to configure the ordering and combination process in the DataReader and can be used to support two different use cases:

    \liOrdered delivery of samples in high-availability scenarios One example of this is RTI Persistence Service. When a late-joining DataReader configured with DDS.DurabilityQosPolicy set to DDS.PERSISTENT_DURABILITY_QOS or DDS.TRANSIENT_DURABILITY_QOS joins a DDS domain, it will start receiving historical samples from multiple DataWriters. For example, if the original DataWriter is still alive, the newly created DataReader will receive samples from the original DataWriter and one or more RTI Persistence Service DataWriters (PRSTDataWriters). This policy can be used to configure the sample ordering process on the DataReader.

    \liOrdered delivery of samples in load-balanced scenarios Multiple instances of the same application can work together to process and deliver samples. When the samples arrive through different data-paths out of order, the DataReader will be able to reconstruct the order at the destination. An example of this is when multiple instances of RTI Persistence Service are used to persist the data. Persisting data to a database on disk can be a bottleneck for throughput. You can improve scalability and performance by dividing the workload across different instances of RTI Persistence Service that use different databases. For example, samples larger than 10 are persisted by Persistence Service 1, samples less than or equal to 10 are persisted by Persistence Service 2.

    \liOrdered delivery of samples with Group Ordered Access This policy can also be used to configure the sample ordering process when the Subscriber is configured with DDS.PresentationQosPolicy access_scope set to DDS.GROUP_PRESENTATION_QOS. In this case, the Subscriber must deliver in order the samples published by a group of DataWriters that belong to the same Publisher and have access_scope set to DDS.GROUP_PRESENTATION_QOS.

    Each sample published in a DDS domain for a given logical data source is uniquely identified by a pair (virtual GUID, virtual sequence number). Samples from the same data source (same virtual GUID) can be published by different DataWriters. A DataReader will deliver a sample (VGUIDn, VSNm) to the application if one of the following conditions is satisfied:

  • (VGUIDn, VSNm-1) has already been delivered to the application.
  • All the known DataWriters publishing VGUIDn have announced that they do not have (VGUIDn, VSNm-1).
  • None of the known DataWriters publishing GUIDn have announced potential availability of (VGUIDn, VSNm-1) and both timeouts in this QoS policy have expired.

    A DataWriter announces potential availability of samples by using virtual heartbeats (HBs).

    When DDS.PresentationQosPolicy.access_scope is set to DDS.TOPIC_PRESENTATION_QOS or DDS.INSTANCE_PRESENTATION_QOS, the virtual HB contains information about the samples contained in the DDS.DataWriter history.

    When DDS.PresentationQosPolicy.access_scope is set to DDS.GROUP_PRESENTATION_QOS, the virtual HB contains information about all DataWriters in the DDS.Publisher.

    The frequency at which virtual HBs are sent is controlled by the protocol parameters DDS.RtpsReliableWriterProtocol_t.virtual_heartbeat_period and DDS.RtpsReliableWriterProtocol_t.samples_per_virtual_heartbeat.

    Required Subscriptions

    In the context of Required Subscriptions, this QoS policy can be used to configure a set of Required Subscriptions on a DDS.DataWriter.

    Required subscriptions are preconfigured, named subscriptions that may leave and subsequently rejoin the network from time to time, at the same or different physical locations. Any time a required subscription is disconnected, any samples that would have been delivered to it are stored for delivery if and when the subscription rejoins the network.

    Consistency

    For a DataWriter, the setting of DDSAvailabilityQosModule must be set consistenly with that of the DDSReliabilityQosModule and DDSDurabilityQosModule.

    If DDS.AvailabilityQosPolicy.enable_required_subscriptions is set to DDS.BOOLEAN_TRUE, DDS.ReliabilityQosPolicy.kind must be set to DDS.RELIABLE_RELIABILITY_QOS and DDS.DurabilityQosPolicy must be set to a value different than DDS.VOLATILE_DURABILITY_QOS.

    enable_required_subscriptions: Enables support for required subscriptions in a DDS.DataWriter

    [default] DDS.BOOLEAN_FALSE

    max_data_availability_waiting_time: Defines how much time to wait before delivering a sample to the application without having received some of the previous samples.

    Collaborative DataWriters

    A sample identified by (VGUIDn, VSNm) will be delivered to the application if this timeout expires for the sample and the following two conditions are satisfied:

  • None of the known DataWriters publishing VGUIDn have announced potential availability of (VGUIDn, VSNm-1).
  • The DataWriters for all the endpoint groups specified in required_matched_endpoint_groups have been discovered or max_endpoint_availability_waiting_time has expired.

    Required Subscriptions

    This field is not applicable to Required Subscriptions.

    [default] DDS_DURATION_AUTO (DDS_DURATION_INFINITE for DDS.GROUP_PRESENTATION_QOS. Otherwise, 0 seconds)

    [range] [0, DDS_DURATION_INFINITE], DDS_DURATION_AUTO

    max_endpoint_availability_waiting_time: Defines how much time to wait to discover DataWriters providing samples for the same data source (virtual GUID).

    Collaborative DataWriters

    The set of endpoint groups that are required to provide samples for a data source can be configured using required_matched_endpoint_groups.

    A non-consecutive sample identified by (VGUIDn, VSNm) cannot be delivered to the application unless DataWriters for all the endpoint groups in required_matched_endpoint_groups are discovered or this timeout expires.

    Required Subscriptions

    This field is not applicable to Required Subscriptions.

    [default] DDS_DURATION_AUTO (DDS_DURATION_INFINITE for DDS.GROUP_PRESENTATION_QOS. Otherwise, 0 seconds)

    [range] [0, DDS_DURATION_INFINITE], DDS_DURATION_AUTO

    required_matched_endpoint_groups: A sequence of endpoint groups.

    Collaborative DataWriters

    In the context of Collaborative DataWriters, it specifies the set of endpoint groups that are expected to provide samples for the same data source.

    The quorum count in a group represents the number of DataWriters that must be discovered for that group before the DataReader is allowed to provide non consecutive samples to the application.

    A DataWriter becomes a member of an endpoint group by configuring the role_name in DDS.DataWriterQos.publication_name.

    Required Subscriptions

    In the context of Required Subscriptions, it specifies the set of Required Subscriptions on a DDS.DataWriter.

    Each Required Subscription is specified by a name and a quorum count.

    The quorum count represents the number of DataReaders that have to acknowledge the sample before it can be considered fully acknowledged for that Required Subscription.

    A DataReader is associated with a Required Subscription by configuring the role_name in DDS.DataReaderQos.subscription_name.

    [default] Empty sequence

  • ContentFilterProperty_T

    type ContentFilterProperty_T is record
          Content_Filter_Topic_Name : aliased DDS.String;
          Related_Topic_Name        : aliased DDS.String;
          Filter_Class_Name         : aliased DDS.String;
          Filter_Expression         : aliased DDS.String;
          Expression_Parameters     : aliased DDS.String_Seq.Sequence;
       end record with Convention => C;

    Summary: <<ext>> Type used to provide all the required information to enable content filtering.

    Content_Filter_Topic_Name: Name of the Content-filtered Topic associated with the Reader.

    Related_Topic_Name: Name of the Topic related to the Content-filtered Topic.

    Filter_Class_Name: Identifies the filter class this filter belongs to. RTPS can support multiple filter classes (SQL, regular expressions, custom filters, etc).

    Filter_Expression: The actual filter expression. Must be a valid expression for the filter class specified using filterClassName.

    Expression_Parameters: Defines the value for each parameter in the filter expression.

    EntityNameQosPolicy

    type EntityNameQosPolicy is record
          Name      : aliased DDS.String;
          Role_Name : aliased DDS.String;
       end record with Convention => C;

    Summary: Assigns a name and a role name to a DDS.DomainParticipant, DDS.Publisher, DDS.Subscriber, DDS.DataWriter or DDS.DataReader. Except for DDS.Publisher and DDS.Subscriber, these names will be visible during the discovery process and in RTI tools to help you visualize and debug your system.

    Entity:
    DDS.DomainParticipant, DDS.Subscriber, DDS.Publisher, DDS.DataReader, DDS.DataWriter

    Properties:
    "Rx0" = NO;
    "Changeable" = "UNTIL ENABLE"

    Usage

    The name and role name can only be 255 characters in length.

    Name: The name of the entity.

    [default] null

    [range] Null terminated string with length not exceeding 255. It can be null.

    Role_Name: The entity role name.

    With Durable Subscriptions this name is used to specify to which Durable Subscription the DDS.DataReader belongs.

    With Collaborative DataWriters this name is used to specify to which endpoint group the DDS.DataWriter belongs.

    [range] Null terminated string with length not exceeding 255. It can be null.

    [default] null

    ProfileQosPolicy

    type ProfileQosPolicy is record
          String_Profile                  : aliased String_Seq.Sequence;
          Url_Profile                     : aliased String_Seq.Sequence;
          Ignore_User_Profile             : aliased Boolean := False;
          Ignore_Environment_Profile      : aliased Boolean := False;
          Ignore_Resource_Profile         : aliased Boolean := False;
          String_Profile_Dtd              : aliased String_Seq.Sequence;
          Ignore_Is_Default_Qos_Attribute :  aliased Boolean := False;
       end record with Convention => C;

    Summary: Configures the way that XML documents containing QoS profiles are loaded by dds.

    All QoS values for Entities can be configured in QoS profiles defined in XML documents. XML documents can be passed to RTI Connext in string form or, more likely, through files found on a file system.

    There are also default locations where DomainParticipants will look for files to load QoS profiles. These include the current working directory from where an application is started, a file in the distribution directory for dds, and the locations specified by an environment variable.

    You may disable any or all of these default locations using the Profile QoS policy.

    Entity:
    DDS.DomainParticipantFactory

    Properties:
    "Rx0" = NO
    "Changeable" = \prop_changeable

    String_Profile: Sequence of strings containing a XML document to load.

    The concatenation of the strings in this sequence must be a valid XML document according to the XML QoS profile schema.

    [default] Empty sequence (zero-length).

    Url_Profile: Sequence of XMLUrlGroups containing a set of XML documents to load.

    Only one of the elements of each group will be loaded by dds, starting from the left.

    [default] Empty sequence (zero-length).

    Ignore_User_Profile: Ignores the file USER_QOS_PROFILES.xml in the current working directory.

    When this field is set to DDS.BOOLEAN_TRUE, the QoS profiles contained in the file USER_QOS_PROFILES.xml in the current working directory will be ignored.

    [default] DDS.BOOLEAN_FALSE

    Ignore_Envionrment_Profile: Ignores the value of the XMLEnvironmentVariable.

    When this field is set to DDS.BOOLEAN_TRUE, the value of the environment variable NDDS_QOS_PROFILES will be ignored.

    [default] DDS.BOOLEAN_FALSE

    Ignore_Resource_Profile: Ignores the file NDDS_QOS_PROFILES.xml.

    When this field is set to DDS.BOOLEAN_TRUE, the QoS profiles contained in the file NDDS_QOS_PROFILES.xml in $NDDSHOME/resource/xml will be ignored.

    [default] DDS.BOOLEAN_FALSE

    SampleIdentity_T

    type SampleIdentity_T is record
          Writer_Guid     : aliased Guid_T;
          Sequence_Number : aliased DDS.SequenceNumber_T;
       end record with
         Convention => C;

    Summary: Type definition for a Sample Identity.

    A SampleIdentity defines a pair (Virtual Writer GUID, Sequence Number) that uniquely identifies a sample within a DDS domain and a Topic.

    Writer_Guid: 16-byte identifier identifying the virtual GUID.

    Sequence_Number: monotonically increasing 64-bit integer that identifies the sample in the data source.

    Cookie_T

    type Cookie_T is record
          Value : aliased Octet_Seq.Sequence;
       end record with Convention => C;

    Cookie_T_Access

    type Cookie_T_Access is access all Cookie_T;

    Cookie_T_Array

    type Cookie_T_Array is array (Natural range <>) of aliased Cookie_T;

    AckResponseData_T

    type AckResponseData_T is record
          Value     : aliased Octet_Seq.Sequence;
       end record with
         Convention => C;

    Summary: Data payload of an application-level acknowledgment

    Value: a sequence of octets

    [default] empty (zero-length)

    [range] Octet sequence of length [0, DDS.DataReaderResourceLimitsQosPolicy.max_app_ack_response_length],

    SampleFlagBits

    type SampleFlagBits is new Unsigned_Long;
    ---------------------------------------------------------- SampleFlag ----------------------------------------------------------

    SampleFlag

    type SampleFlag is new DDS.Long;

    WriteParams_T

    type WriteParams_T is record
          Replace_Auto            : aliased DDS.Boolean  := False;
          Identity                : aliased SampleIdentity_T := AUTO_SAMPLE_IDENTITY;
          Related_Sample_Identity : aliased SampleIdentity_T := UNKNOWN_SAMPLE_IDENTITY;
          Source_Timestamp        : aliased DDS.Time_T := (-1, 0);
          Cookie                  : aliased DDS.Cookie_T := COOKIE_DEFAULT;
          Handle                  : aliased DDS.InstanceHandle_T := Null_InstanceHandle_T;
          Priority                : aliased Long := 0;
          Flush_On_Write          : aliased DDS.Boolean := False;
          Flag                    : aliased SampleFlag := 0;
          Source_Guid             : aliased Guid_T := GUID_AUTO;
          Related_Source_Guid     : aliased Guid_T := GUID_UNKNOWN;
          Related_Reader_Guid     : aliased Guid_T := GUID_UNKNOWN;
          Topic_Query_Guid        : aliased Guid_T := GUID_UNKNOWN;
       end record with
         Convention => C;

    Summary: <<ext>> Input parameters for writing with FooDataWriter.write_w_params, FooDataWriter.dispose_w_params, FooDataWriter.register_instance_w_params, FooDataWriter.unregister_instance_w_params

    When this field is set, the fields that were configured with an automatic value (for example, DDS_AUTO_SAMPLE_IDENTITY) receive their actual value after FooDataWriter.write_w_params is called.

    To reset those fields to their automatic value after calling FooDataWriter.write_w_params, use DDS_WriteParams_reset

    Replace_Auto: Allows retrieving the actual value of those fields that were automatic

    When this field is set, the fields that were configured with an automatic value (for example, DDS_AUTO_SAMPLE_IDENTITY) receive their actual value after FooDataWriter.write_w_params is called.

    To reset those fields to their automatic value after calling FooDataWriter.write_w_params, use DDS_WriteParams_reset

    Identity: Identity of the sample.

    Identifies the sample being written. The identity consists of a pair (Virtual Writer GUID, Virtual Sequence Number).

    Use the default value to let RTI Connext determine the sample identity as follows:

  • The Virtual Writer GUID is the virtual GUID associated with the writer writing the sample. This virtual GUID is configured using DDS.DataWriterProtocolQosPolicy.virtual_guid.

  • The sequence number is increased by one with respect to the previous value.

    The virtual sequence numbers for a virtual writer must be strictly monotonically increasing. If the user tries to write a sample with a sequence number smaller or equal to the last sequence number, the write operation will fail.

    A DataReader can access the identity of a received sample by using the fields DDS.SampleInfo.original_publication_virtual_guid and DDS.SampleInfo.original_publication_virtual_sequence_number in the DDS.SampleInfo.

    [default] DDS_AUTO_SAMPLE_IDENTITY.

    Related_Sample_Identity: The identity of another sample related to this one

    Identifies another sample that is logically related to the one that is written.

    When this field is set, the related sample identity is propagated and subscribing applications can retrieve it from the DDS.SampleInfo (see DDS_SampleInfo_get_related_sample_identity).

    The default value is DDS_UNKNOWN_SAMPLE_IDENTITY, and is not propagated.

    A DataReader can access the related identity of a received sample by using the fields DDS.SampleInfo.related_original_publication_virtual_guid and DDS.SampleInfo.related_original_publication_virtual_sequence_number in the DDS.SampleInfo.

    [default] DDS_UNKNOWN_SAMPLE_IDENTITY

    Source_Timestamp: Source timestamp upon write

    Specifies the source timestamp that will be available to the DDS.DataReader objects by means of the source_timestamp attribute within the DDS.SampleInfo.

    [default] DDS_TIME_INVALID.

    Cookie: Octet sequence identifying written data sample

    Used in the callback DDS.DataWriterListener.on_application_acknowledgment to associate acknowledgments to samples.

    The maximum size of the cookie is configurable using the field DDS.DataWriterResourceLimitsQosPolicy.cookie_max_length.

    [default] Empty sequence (zero-length).

    Handle: Instance handle

    Either the handle returned by a previous call to FooDataWriter.register_instance, or else the special value DDS_HANDLE_NIL.

    [default] DDS_HANDLE_NIL

    Priority: Publication priority

    A positive integer value designating the relative priority of the sample, used to determine the transmission order of pending writes.

    Use of publication priorities requires an asynchronous publisher (DDS.ASYNCHRONOUS_PUBLISH_MODE_QOS) with DDS.FlowControllerProperty_t.scheduling_policy set to DDS.HPF_FLOW_CONTROLLER_SCHED_POLICY.

    Larger numbers have higher priority.

    For multi-channel DataWriters, the publication priority of a sample may be used as a filter criteria for determining channel membership.

    If the publication priority of the parent DataWriter, or for multi-channel DataWriters, if the publication priority of the parent channel, is set to DDS.PUBLICATION_PRIORITY_AUTOMATIC, then the DataWriter or channel will be assigned the priority of the largest publication priority of all samples in the DataWriter or channel.

    If the publication priority of the parent DataWriter, and for multi-channel DataWriters, if the publication priority of the parent channel, are set to DDS.PUBLICATION_PRIORITY_UNDEFINED, then the DataWriter or channel will be assigned the lowest priority, regardless of the value of the publication priorities of samples written to the DataWriter or channel.

    The publication priority of each sample can be set in the DDS_WriteParams_t of FooDataWriter.write_w_params.

    For dispose and unregister samples, use the DDS_WriteParams_t of FooDataWriter.dispose_w_params and FooDataWriter.unregister_instance_w_params.

    [default] 0 (lowest priority)


    See also: DDS.ChannelSettings_t.priority

    Source_Guid: Identifies the application logical data source associated with the sample being written.

    When this field is set, the source_guid is propagated and subscribing applications can retrieve it from the DDS.SampleInfo (see DDS.SampleInfo.source_guid).

    The default value is DDS_GUID_AUTO, and is not propagated.

    The main use case for source_guid and related_source_guid is a request/reply scenario in which a reply has to be sent only to the Requester that issue the related request.

    In this case, the Requester's DataWriter will send a request setting the source_guid to an unique value. This value must be the same value even after Requester restart.

    The Replier's DataReader will get the request's source_guid from the SampleInfo and it will send it as the related_source_guid of the reply using the Replier's DataWriter.

    The Requester's DataReader will install a CFT on the related_source_guid using a filter expression. For example:

                      @related_source_guid.value = &hex(00000000000000000000000000000001)                  

    This way the reply will be send only to the right Requester.

    The source_guid and related_source_guid fields are used by RTI Queuing Service in a request/reply scenario.

    [default] DDS_GUID_AUTO (the source_guid is automatically set to the DDS.DataWriter virtual GUID). \see DDS_WriteParams_t.related_source_guid

    Related_Source_Guid: Identifies the application logical data source that is related to the sample being written.

    When this field is set, the related_source_guid is propagated and subscribing applications can retrieve it from the DDS.SampleInfo (see DDS.SampleInfo.related_source_guid).

    The default value is DDS_GUID_UNKNOWN, and is not propagated.

    [default] DDS_GUID_UNKNOWN \see DDS_WriteParams_t.source_guid

    Related_Reader_Guid: Identifies a DataReader that is logically related to the sample that is being written.

    When this field is set, the related_reader_guid is propagated and subscribing applications can retrieve it from the DDS.SampleInfo (see DDS.SampleInfo.related_subscription_guid).

    The default value is DDS_GUID_UNKNOWN, and is not propagated.

    The main use case for this field is point-to-point sample distribution using CFT. DataReaders install a CFT on the related_reader_guid using a unique GUID. For example, the filter for DataReader 'n' can be:

                      @related_reader_guid.value = &hex(00000000000000000000000000000001)                  

    Then, a DataWriter that wants to send the sample to DataReader 'n' will use the FooDataWriter.write_w_params procedure and set related_reader_guid to the value used by DataReader 'n' in its filter expression.

    This field is currently used by RTI Queuing Service to distribute a sample to only one of the Consumer's DataReaders attached to a SharedReaderQueue.

    [default] DDS_GUID_UNKNOWN

  • WriteParams_T_Access

    type WriteParams_T_Access is access all WriteParams_T;

    TypeCode

    type TypeCode is new RTIDDS.Low_Level.dds_c.typecode_h.DDS_TypeCode;

    TypeCode_Access

    type TypeCode_Access is access all TypeCode;

    TypeObject

    subtype TypeObject is RTIDDS.Low_Level.dds_c.typeobject_h.DDS_Type;

    TypeObject_Access

    type TypeObject_Access is access all TypeObject;

    Transport_ClassId_T

    type Transport_ClassId_T is new Long;

    TransportInfo_T

    type TransportInfo_T is record
          Class_Id         : aliased Transport_ClassId_T := 0;  -- ndds/dds_c/dds_c_infrastructure.h:3672
          Message_Size_Max : aliased Long := 1024;  -- ndds/dds_c/dds_c_infrastructure.h:3676
       end record with Convention => C;

    Summary: Contains the class_id and message_size_max of an installed transport.

    class_id: The class_id identifies the transport associated with the message_size_max.

    message_size_max: The maximum size of an RTPS message in bytes that can be sent or received by the transport plugin identified by the class_id.

    TransportInfo_Access

    type TransportInfo_Access is access all TransportInfo_T;

    TransportInfo_Array

    type TransportInfo_Array is array (Natural range <>) of aliased TransportInfo_T with Convention => C;

    ParticipantBuiltinTopicData

    type ParticipantBuiltinTopicData is record
          Key                            : aliased BuiltinTopicKey_T;
          User_Data                      : aliased UserDataQosPolicy;
          --  --- Extensions: ----------------------------------------------------
          Property                       : aliased PropertyQosPolicy;
          Rtps_Protocol_Version          : aliased ProtocolVersion_T;
          Rtps_Vendor_Id                 : aliased VendorId_T;
          Dds_Builtin_Endpoints          : aliased Unsigned_Long := 0;
          Metatraffic_Unicast_Locators   : aliased Locator_Seq.Sequence;
          Metatraffic_Multicast_Locators : aliased Locator_Seq.Sequence;
          Default_Unicast_Locators       : aliased Locator_Seq.Sequence;
          Lease_Duration                 : aliased Duration_T;
          Product_Version                : aliased ProductVersion_T;
          Plugin_Promiscuity_Kind        : aliased DiscoveryPluginPromiscuityKind := DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY;
          Participant_Name               : aliased EntityNameQosPolicy;
          Domain_Id                      : aliased DomainId_T := 0;  -- ndds/dds_c/dds_c_builtin.h:105
          Transport_Info                 : aliased RTIDDS.Low_Level.dds_c.infrastructure_h.DDS_TransportInfoSeq;  -- ndds/dds_c/dds_c_builtin.h:109
          Reachability_Lease_Duration    : aliased Duration_T;
          Vendor_Builtin_Endpoints       : aliased Unsigned_Long := 0;
          Service                        : aliased ServiceQosPolicy;
    
       end record with
         Convention => C;

    Summary: Entry created when a DomainParticipant object is discovered.

    Data associated with the built-in topic DDS.PARTICIPANT_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.DomainParticipant.


    See also: DDS.PARTICIPANT_TOPIC_NAME
    See also: DDS.ParticipantBuiltinTopicDataDataReader

    Key: DCPS key to distinguish entries.

    User_Data: Policy of the corresponding DomainParticipant.

    Property: <<ext>> Name value pair properties to be stored with domain participant

    Rtps_Protocol_Version: <<ext>> Version number of the RTPS wire protocol used.

    Rtps_Vendor_Id: <<ext>> ID of vendor implementing the RTPS wire protocol.

    Dds_Builtin_Endpoints: <<ext>> Bitmap of builtin endpoints supported by the participant.

    Each bit indicates a builtin endpoint that may be available on the participant for use in discovery.

    Default_Unicast_Locators: <<ext>> Unicast locators used when individual entities do not specify unicast locators.

    Product_Version: <<ext>> This is a vendor specific parameter. It gives the current version for rti-dds.

    Participant_Name: <<ext>> The participant name and role name.

    This parameter contains the name and the role name of the discovered participant.

    domain_id: <<ext>> Domain ID associated with the discovered participant.

    transport_info: <<ext>> A sequence of DDS.TransportInfo_t containing information about each of the installed transports of the discovered participant.

    This parameter contains a sequence of DDS.TransportInfo_t containing the class_id and message_size_max for all installed transports of the discovered participant. The maximum number of DDS.TransportInfo_t that will be stored in this sequence is controlled by the Domain Participant's resource limit DDS.DomainParticipantResourceLimitsQosPolicy.transport_info_list_max_length.

    TODO: add correct ref tags

    ParticipantBuiltinTopicData_Access

    type ParticipantBuiltinTopicData_Access is access all ParticipantBuiltinTopicData;

    ParticipantBuiltinTopicData_Array

    type ParticipantBuiltinTopicData_Array is array (Natural range <>) of aliased ParticipantBuiltinTopicData;

    TopicBuiltinTopicData

    type TopicBuiltinTopicData is record
          Key                       : aliased BuiltinTopicKey_T;
          Name                      : aliased DDS.String;
          Type_Name                 : aliased DDS.String;
          Durability                : aliased DurabilityQosPolicy;
          Durability_Service        : aliased DurabilityServiceQosPolicy;
          Deadline                  : aliased DeadlineQosPolicy;
          Latency_Budget            : aliased LatencyBudgetQosPolicy;
          Liveliness                : aliased LivelinessQosPolicy;
          Reliability               : aliased ReliabilityQosPolicy;
          Transport_Priority        : aliased TransportPriorityQosPolicy;
          Lifespan                  : aliased LifespanQosPolicy;
          Destination_Order         : aliased DestinationOrderQosPolicy;
          History                   : aliased HistoryQosPolicy;
          Resource_Limits           : aliased ResourceLimitsQosPolicy;
          Ownership                 : aliased OwnershipQosPolicy;
          Topic_Data                : aliased TopicDataQosPolicy;
       end record with
         Convention => C;

    Summary: Entry created when a Topic object discovered.

    Data associated with the built-in topic DDS.TOPIC_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.Topic.

    Note: The DDS.TopicBuiltinTopicData built-in topic is meant to convey information about discovered Topics. This Topic's samples are not propagated in a separate packet on the wire. Instead, the data is sent as part of the information carried by other built-in topics (DDS.PublicationBuiltinTopicData and DDS.SubscriptionBuiltinTopicData). Therefore TopicBuiltinTopicData DataReaders will not receive any data.


    See also: DDS.TOPIC_TOPIC_NAME
    See also: DDS.TopicBuiltinTopicDataDataReader

    Data associated with the built-in topic DDS.TOPIC_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.Topic.

    Note: The DDS.TopicBuiltinTopicData built-in topic is meant to convey information about discovered Topics. This Topic's samples are not propagated in a separate packet on the wire. Instead, the data is sent as part of the information carried by other built-in topics (DDS.PublicationBuiltinTopicData and DDS.SubscriptionBuiltinTopicData). Therefore TopicBuiltinTopicData DataReaders will not receive any data.

    Key: DCPS key to distinguish entries.

    Name: Name of the DDS.Topic.

    The length of this string is limited to 255 characters.

    Type_Name: Name of the type attached to the DDS.Topic.

    The length of this string is limited to 255 characters.

    Durability: durability policy of the corresponding Topic

    Durability_Service: durability service policy of the corresponding Topic

    Deadline: Policy of the corresponding Topic

    Latency_Budget: Policy of the corresponding Topic

    Liveliness: Policy of the corresponding Topic

    Reliability: Policy of the corresponding Topic

    Transport_Priority: Policy of the corresponding Topic

    Lifespan: Policy of the corresponding Topic

    Destination_Order: Policy of the corresponding Topic

    History: Policy of the corresponding Topic

    Resource_Limits: Policy of the corresponding Topic

    Ownership: Policy of the corresponding Topic

    Topic_Data: Policy of the corresponding Topic

    TopicBuiltinTopicData_Access

    type TopicBuiltinTopicData_Access is access all TopicBuiltinTopicData;

    TopicBuiltinTopicData_Array

    type TopicBuiltinTopicData_Array is array (Natural range <>) of aliased TopicBuiltinTopicData;

    ServiceRequestInternalTopicData

    type ServiceRequestInternalTopicData is record
           Service_Id                : aliased Long := 0;
           Instance_Id               : aliased Guid_T;
           Request_Body              : aliased RTIDDS.Low_Level.dds_c.infrastructure_h.DDS_OctetSeq;
       end record with Convention => C;

    ServiceRequestInternalTopicData_Access

    type ServiceRequestInternalTopicData_Access is access all ServiceRequestInternalTopicData;
    TODO: Add ref tags

    PublicationBuiltinTopicData

    type PublicationBuiltinTopicData is record
          Key                       : aliased BuiltinTopicKey_T;
          Participant_Key           : aliased BuiltinTopicKey_T;
          Topic_Name                : aliased DDS.String;
          Type_Name                 : aliased DDS.String;
          Max_Sample_Serialize_Size : aliased Long := 0;
          Durability                : aliased DurabilityQosPolicy;
          Durability_Service        : aliased DurabilityServiceQosPolicy;
          Deadline                  : aliased DeadlineQosPolicy;
          Latency_Budget            : aliased LatencyBudgetQosPolicy;
          Liveliness                : aliased LivelinessQosPolicy;
          Reliability               : aliased ReliabilityQosPolicy;
          Lifespan                  : aliased LifespanQosPolicy;
          User_Data                 : aliased UserDataQosPolicy;
          Ownership                 : aliased OwnershipQosPolicy;
          Ownership_Strength        : aliased OwnershipStrengthQosPolicy;
          Destination_Order         : aliased DestinationOrderQosPolicy;
          Presentation              : aliased PresentationQosPolicy;
          Partition                 : aliased PartitionQosPolicy;
          Topic_Data                : aliased TopicDataQosPolicy;
          Group_Data                : aliased GroupDataQosPolicy;
          Type_Object               : aliased TypeObject_Access;
          --  extensions
          Type_Code                 : aliased TypeCode_Access;
          Publisher_Key             : aliased BuiltinTopicKey_T;
          Property                  : aliased PropertyQosPolicy;
          Unicast_Locators          : aliased Locator_Seq.Sequence;
          Virtual_Guid              : aliased Guid_T;
          Service                   : aliased ServiceQosPolicy;
          Rtps_Protocol_Version     : aliased ProtocolVersion_T;
          Rtps_Vendor_Id            : aliased VendorId_T;
          Product_Version           : aliased ProductVersion_T;
          Locator_Filter            : aliased LocatorFilterQosPolicy;
          Disable_Positive_Acks     : aliased Boolean := False;
          Send_Queue_Size           : aliased Long := 0;
          Is_Incompatible           : aliased Boolean := False;
          Publication_Name          : aliased EntityNameQosPolicy;
       end record with
         Convention => C;

    Summary: Entry created when a DDS.DataWriter is discovered in association with its Publisher.

    Data associated with the built-in topic DDS.PUBLICATION_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.DataWriter the related DDS.Publisher.
    See also: DDS.PUBLICATION_TOPIC_NAME
    See also: DDS.PublicationBuiltinTopicDataDataReader

    Data associated with the built-in topic DDS.PUBLICATION_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.DataWriter the related DDS.Publisher.

    Key: DCPS key to distinguish entries

    Participant_Key: DCPS key of the participant to which the DataWriter belongs

    Topic_Name: Name of the related DDS.Topic.

    The length of this string is limited to 255 characters.

    Type_Name: Name of the type attached to the DDS.Topic.

    The length of this string is limited to 255 characters.

    Durability: durability policy of the corresponding DataWriter

    Durability_Service: durability_service policy of the corresponding DataWriter

    Deadline: Policy of the corresponding DataWriter

    Latency_Budget: Policy of the corresponding DataWriter

    Liveliness: Policy of the corresponding DataWriter

    Reliability: Policy of the corresponding DataWriter

    Lifespan: Policy of the corresponding DataWriter

    User_Data: Policy of the corresponding DataWriter

    Ownership: Policy of the corresponding DataWriter

    Ownership_Strength: Policy of the corresponding DataWriter

    Destination_Order: Policy of the corresponding DataWriter

    Presentation: Policy of the Publisher to which the DataWriter belongs

    Partition: Policy of the Publisher to which the DataWriter belongs

    Topic_Data: Policy of the related Topic

    Group_Data: Policy of the Publisher to which the DataWriter belongs

    Type_Code: <<ext>> Type code information of the corresponding Topic

    Publisher_Key: <<ext>> DCPS key of the publisher to which the DataWriter belongs

    Property: <<ext>> Properties of the corresponding DataWriter.

    Unicast_Locators: <<ext>> Custom unicast locators that the endpoint can specify. The default locators will be used if this is not specified.

    Virtual_Guid: <<ext>> Virtual GUID associated to the DataWriter.


    See also: DDS.GUID_t

    Service: <<ext>> Policy of the corresponding DataWriter.

    Rtps_Protocol_Version: <<ext>> Version number of the RTPS wire protocol used.

    Rtps_Vendor_Id: <<ext>> ID of vendor implementing the RTPS wire protocol.

    Product_Version: <<ext>> This is a vendor specific parameter. It gives the current version for rti-dds.

    locator_filter: <<ext>> Policy of the corresponding DataWriter

    Related to DDS.MultiChannelQosPolicy.

    disable_positive_acks: <<ext>> This is a vendor specific parameter. Determines whether matching DataReaders send positive acknowledgements for reliability.

    publication_name: <<ext>> The publication name and role name.

    This member contains the name and the role name of the discovered publication.

    PublicationBuiltinTopicData_Access

    type PublicationBuiltinTopicData_Access is access all PublicationBuiltinTopicData;

    PublicationBuiltinTopicData_Array

    type PublicationBuiltinTopicData_Array is array (Natural range <>) of aliased PublicationBuiltinTopicData;

    SubscriptionBuiltinTopicData

    type SubscriptionBuiltinTopicData is record
          Key                     : aliased BuiltinTopicKey_T;
          Participant_Key         : aliased BuiltinTopicKey_T;
          Topic_Name              : aliased DDS.String;
          Type_Name               : aliased DDS.String;
          Durability              : aliased DurabilityQosPolicy;
          Deadline                : aliased DeadlineQosPolicy;
          Latency_Budget          : aliased LatencyBudgetQosPolicy;
          Liveliness              : aliased LivelinessQosPolicy;
          Reliability             : aliased ReliabilityQosPolicy;
          Ownership               : aliased OwnershipQosPolicy;
          Destination_Order       : aliased DestinationOrderQosPolicy;
          User_Data               : aliased UserDataQosPolicy;
          Time_Based_Filter       : aliased TimeBasedFilterQosPolicy;
          Presentation            : aliased PresentationQosPolicy;
          Partition               : aliased PartitionQosPolicy;
          Topic_Data              : aliased TopicDataQosPolicy;
          Group_Data              : aliased GroupDataQosPolicy;
          Type_Consistency        : aliased TypeConsistencyEnforcementQosPolicy;
          Type_Object             : aliased TypeObject_Access;
          --  extensions
          Type_Code               : aliased TypeCode_Access;
          Subscriber_Key          : aliased BuiltinTopicKey_T;
          Property                : aliased PropertyQosPolicy;
          Unicast_Locators        : aliased Locator_Seq.Sequence;
          Multicast_Locators      : aliased Locator_Seq.Sequence;
          Content_Filter_Property : aliased ContentFilterProperty_T;
          Virtual_Guid            : aliased Guid_T;
          Service                 : aliased ServiceQosPolicy;
          Rtps_Protocol_Version   : aliased ProtocolVersion_T;
          Rtps_Vendor_Id          : aliased VendorId_T;
          Product_Version         : aliased ProductVersion_T;
          Disable_Positive_Acks   : aliased Boolean := False;
          Expects_Inline_Qos      : aliased Boolean := False;
          Receive_Queue_Size      : aliased Long := 0;
          Is_Incompatible         : aliased Boolean := False;
          Subscription_Name       : aliased EntityNameQosPolicy;
       end record with
         Convention => C;

    Summary: Entry created when a DDS.DataReader is discovered in association with its Subscriber.

    Data associated with the built-in topic DDS.SUBSCRIPTION_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.DataReader the related DDS.Subscriber.


    See also: DDS.SUBSCRIPTION_TOPIC_NAME
    See also: DDS.SubscriptionBuiltinTopicDataDataReader

    Data associated with the built-in topic DDS.SUBSCRIPTION_TOPIC_NAME. It contains QoS policies and additional information that apply to the remote DDS.DataReader the related DDS.Subscriber.

    Key: DCPS key to distinguish entries

    Participant_Key: DCPS key of the participant to which the DataReader belongs.

    Topic_Name: Name of the related DDS.Topic.

    The length of this string is limited to 255 characters.

    Type_Name: Name of the type attached to the DDS.Topic.

    The length of this string is limited to 255 characters.

    Durability: Policy of the corresponding DataReader

    Deadline: Policy of the corresponding DataReader

    Latency_Budget: Policy of the corresponding DataReader

    Liveliness: Policy of the corresponding DataReader

    Reliability: Policy of the corresponding DataReader

    Ownership: Policy of the corresponding DataReader

    Destination_Order: Policy of the corresponding DataReader

    User_Data: Policy of the corresponding DataReader

    Time_Based_Filter: Policy of the corresponding DataReader

    Presentation: Policy of the Subscriber to which the DataReader belongs

    Partition: Policy of the Subscriber to which the DataReader belongs

    Topic_Data: Policy of the related Topic

    Group_Data: Policy of the Subscriber to which the DataReader belongs

    Type_Consistency: Policy of the corresponding DataReader

    Type_Code: <<ext>> Type code information of the corresponding Topic

    Subscriber_Key: <<ext>> DCPS key of the subscriber to which the DataReader belongs.

    Property: <<ext>> Properties of the corresponding DataReader.

    Unicast_Locators: <<ext>> Custom unicast locators that the endpoint can specify. The default locators will be used if this is not specified.

    Multicast_Locators: <<ext>> Custom multicast locators that the endpoint can specify. The default locators will be used if this is not specified.

    Content_Filter_Property: <<ext>> This field provides all the required information to enable content filtering on the Writer side.

    Virtual_Guid: <<ext>> Virtual GUID associated to the DataReader.


    See also: DDS.GUID_t

    Service: <<ext>> Policy of the corresponding DataReader.

    Rtps_Protocol_Version: <<ext>> Version number of the RTPS wire protocol used.

    Rtps_Vendor_Id: <<ext>> ID of vendor implementing the RTPS wire protocol.

    Product_Version: <<ext>> This is a vendor specific parameter. It gives the current version of RTI Connext

    disable_positive_acks: <<ext>> This is a vendor specific parameter. Determines whether the corresponding DataReader sends positive acknowledgments for reliability.

    subscription_name: <<ext>> The subscription name and role name.

    This member contains the name and the role name of the discovered subscription.

    SubscriptionBuiltinTopicData_Access

    type SubscriptionBuiltinTopicData_Access is access all SubscriptionBuiltinTopicData;

    SubscriptionBuiltinTopicData_Array

    type SubscriptionBuiltinTopicData_Array is array (Natural range <>) of aliased SubscriptionBuiltinTopicData;

    KeyHash_Value_Array

    type KeyHash_Value_Array is array (0 .. 15) of aliased DDS.Octet;

    KeyHash_T

    type KeyHash_T is record
          Value  : aliased KeyHash_Value_Array := (others => 0);
          Length : aliased DDS.Unsigned_Long := 0;
       end record with
         Convention => C;

    InconsistentTopicStatus

    type InconsistentTopicStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
       end record with
         Convention => C;

    Entity:
    DDS.Topic

    Listener:
    DDS.TopicListener

    Every time a DDS.DataReader and DDS.DataWriter with the same DDS.Topic do not match because the type-consistency enforcement policy fails, the inconsistent topic status is updated for the DDS.Topic.


    See also: DDS.TypeConsistencyEnforcementQosPolicy

    Total_Count: Total cumulative count of the pairs (DDS.DataReader,DDS.DataWriter) whose topic names match the DDS.Topic to which this status is attached and whose types are inconsistent according to the rules defined in DDS.TypeConsistencyEnforcementQosPolicy.

    Total_Count_Change: The incremental number of inconsistent pairs (DDS.DataReader,DDS.DataWriter) for the DDS.Topic to which this status is attached, that have been discovered since the last time this status was read.

    TopicQos_Access

    type TopicQos_Access is access TopicQos;

    OfferedDeadlineMissedStatus

    type OfferedDeadlineMissedStatus is record
          Total_Count          : aliased Long := 0;
          Total_Count_Change   : aliased Long := 0;
          Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record with
         Convention => C;

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    The deadline that the DDS.DataWriter has committed through its DDS.DeadlineQosPolicy was not respected for a specific instance.

    Total_Count: Total cumulative count of the number of times the DDS.DataWriter failed to write within its offered deadline.

    Missed deadlines accumulate; that is, each deadline period the total_count will be incremented by one.

    Total_Count_Change: The incremental changes in total_count since the last time the listener was called or the status was read.

    Last_Instance_Handle: Handle to the last instance in the DDS.DataWriter for which an offered deadline was missed.

    LivelinessLostStatus

    type LivelinessLostStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
       end record with
         Convention => C;

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    The liveliness that the DDS.DataWriter has committed through its DDS.LivelinessQosPolicy was not respected; thus DDS.DataReader entities will consider the DDS.DataWriter as no longer "alive/active".

    Total_Count: Total cumulative number of times that a previously-alive DDS.DataWriter became not alive due to a failure to to actively signal its liveliness within the offered liveliness period.

    This count does not change when an already not alive DDS.DataWriter simply remains not alive for another liveliness period.

    Total_Count_Change: The incremental changees in total_count since the last time the listener was called or the status was read.

    OfferedIncompatibleQosStatus

    type OfferedIncompatibleQosStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
          Last_Policy_Id     : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
          Policies           : aliased QosPolicyCount_Seq.Sequence;
       end record with
         Convention => C;

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    The qos policy value was incompatible with what was requested.

    Total_Count: Total cumulative number of times the concerned DDS.DataWriter discovered a DDS.DataReader for the same DDS.Topic, common partition with a requested QoS that is incompatible with that offered by the DDS.DataWriter.

    Total_Count_Change: The incremental changes in total_count since the last time the listener was called or the status was read.

    Last_Policy_Id: The DDS.QosPolicyId_t of one of the policies that was found to be incompatible the last time an incompatibility was detected.

    Policies: A list containing for each policy the total number of times that the concerned DDS.DataWriter discovered a DDS.DataReader for the same DDS.Topic and common partition with a requested QoS that is incompatible with that offered by the DDS.DataWriter.

    OfferedIncompatibleQosStatus_Access

    type OfferedIncompatibleQosStatus_Access is access all OfferedIncompatibleQosStatus;

    PublicationMatchedStatus

    type PublicationMatchedStatus is record
          Total_Count              : aliased Long := 0;
          Total_Count_Change       : aliased Long := 0;
          Current_Count            : aliased Long := 0;
          Current_Count_Peak       : aliased Long := 0;
          Current_Count_Change     : aliased Long := 0;
          Last_Subscription_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record with
         Convention => C;

    Summary: DDS.PUBLICATION_MATCHED_STATUS

    A "match" happens when the DDS.DataWriter finds a DDS.DataReader for the same DDS.Topic and common partition with a requested QoS that is compatible with that offered by the DDS.DataWriter.

    This status is also changed (and the listener, if any, called) when a match is ended. A local DDS.DataWriter will become "unmatched" from a remote DDS.DataReader when that DDS.DataReader goes away for any reason.

    Total_Count: The total cumulative number of times the concerned DDS.DataWriter discovered a "match" with a DDS.DataReader.

    This number increases whenever a new match is discovered. It does not change when an existing match goes away.

    Total_Count_Change: The incremental changes in total_count since the last time the listener was called or the status was read.

    Current_Count: The current number of readers with which the DDS.DataWriter is matched.

    This number increases when a new match is discovered and decreases when an existing match goes away.

    Current_Count_Peak: <<ext>> The highest value that current_count has reached until now.

    Current_Count_Change: The change in current_count since the last time the listener was called or the status was read.

    Last_Subscription_Handle: A handle to the last DDS.DataReader that caused the the DDS.DataWriter's status to change.

    ReliableWriterCacheEventCount

    type ReliableWriterCacheEventCount is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
       end record;

    Summary: <<ext>> The number of times the number of unacknowledged samples in the cache of a reliable writer hit a certain well-defined threshold.


    See also: DDS.ReliableWriterCacheChangedStatus

    Total_Count: The total number of times the event has occurred.

    Total_Count_Change: The incremental number of times the event has occurred since the listener was last invoked or the status read.

    ReliableWriterCacheChangedStatus

    type ReliableWriterCacheChangedStatus is record
          Empty_Reliable_Writer_Cache          : aliased ReliableWriterCacheEventCount;
          Full_Reliable_Writer_Cache           : aliased ReliableWriterCacheEventCount;
          Low_Watermark_Reliable_Writer_Cache  : aliased ReliableWriterCacheEventCount;
          High_Watermark_Reliable_Writer_Cache : aliased ReliableWriterCacheEventCount;
          Unacknowledged_Sample_Count          : aliased Long := 0;
          Unacknowledged_Sample_Count_Peak     : aliased Long := 0;
       end record;

    Summary: <<ext>> A summary of the state of a data writer's cache of unacknowledged samples written.

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    A written sample is unacknowledged (and therefore accounted for in this status) if the writer is reliable and one or more readers matched with the writer has not yet sent an acknowledgement to the writer declaring that it has received the sample.

    If the low watermark is zero and the unacknowledged sample count decreases to zero, both the low watermark and cache empty events are considered to have taken place. A single callback will be dispatched (assuming the user has requested one) that contains both status changes. The same logic applies when the high watermark is set equal to the maximum number of samples and the cache becomes full.

    Empty_Reliable_Writer_Cache: The number of times the reliable writer's cache of unacknowledged samples has become empty.

    Full_Reliable_Writer_Cache: The number of times the reliable writer's cache, or send window, of unacknowledged samples has become full.

    Applies to writer's cache when the send window is enabled (when both DDS.RtpsReliableWriterProtocol_t.min_send_window_size and DDS.RtpsReliableWriterProtocol_t.max_send_window_size are not DDS.LENGTH_UNLIMITED).

    Otherwise, applies when the number of unacknowledged samples has reached the send window limit.

    Low_Watermark_Reliable_Writer_Cache: The number of times the reliable writer's cache of unacknowledged samples has fallen to the low watermark.

    A low watermark event will only be considered to have taken place when the number of unacknowledged samples in the writer's cache decreases to this value. A sample count that increases to this value will not result in a callback or in a change to the total count of low watermark events.

    When the writer's send window is enabled, the low watermark is scaled down, if necessary, to fit within the current send window.

    High_Watermark_Reliable_Writer_Cache: The number of times the reliable writer's cache of unacknowledged samples has risen to the high watermark.

    A high watermark event will only be considered to have taken place when the number of unacknowledged sampled increases to this value. A sample count that was above this value and then decreases back to it will not trigger an event.

    When the writer's send window is enabled, the high watermark is scaled down, if necessary, to fit within the current send window.

    Unacknowledged_Sample_Count: The current number of unacknowledged samples in the writer's cache.

    A sample is considered unacknowledged if the writer has failed to receive an acknowledgement from one or more reliable readers matched to it.

    Unacknowledged_Sample_Count_peak: The highest value that unacknowledged_sample_count has reached until now.

    ReliableReaderActivityChangedStatus

    type ReliableReaderActivityChangedStatus is record
          Active_Count          : aliased Long := 0;
          Inactive_Count        : aliased Long := 0;
          Active_Count_Change   : aliased Long := 0;
          Inactive_Count_Change : aliased Long := 0;
          Last_Instance_Handle  : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record;

    Summary: <<ext>> Describes the activity (i.e. are acknowledgements forthcoming) of reliable readers matched to a reliable writer.

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    This status is the reciprocal status to the DDS.LivelinessChangedStatus on the reader. It is different than the DDS.LivelinessLostStatus on the writer in that the latter informs the writer about its own liveliness; this status informs the writer about the "liveliness" (activity) of its matched readers.

    All counts in this status will remain at zero for best effort writers.

    Acitve_Count: The current number of reliable readers currently matched with this reliable writer.

    Inacitve_Count: The number of reliable readers that have been dropped by this reliable writer because they failed to send acknowledgements in a timely fashion.

    A reader is considered to be inactive after is has been sent heartbeats DDS.RtpsReliableWriterProtocol_t.max_heartbeat_retries times, each heartbeat having been separated from the previous by the current heartbeat period.

    Active_Count_change: The most recent change in the number of active remote reliable readers.

    Inactive_Count_change: The most recent change in the number of inactive remote reliable readers.

    Last_Instance_Handle: The instance handle of the last reliable remote reader to be determined inactive.

    AcknowledgmentInfo

    type AcknowledgmentInfo is record
          Subscription_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
          Sample_Identity     : aliased SampleIdentity_T;
          Cookie              : aliased Cookie_T;
          Valid_Response_Data : aliased Boolean := False;
          Response_Data       : aliased AckResponseData_T;
       end record;

    Summary: Information about an application-level acknowledged sample

    When acknowledging a sample, the reader provides the writer with information about the sample being acknowledged. The AcknowledgmentInfo structure provides the identity and cookie of the sample being acknowledged, as well as user data payload provided by the reader.

    Subscription_Handle: Subscription handle of the acknowledging DDS.DataReader

    Sample_Identity: Identity of the sample being acknowledged


    See also: DDS.SampleIdentity_t

    Cookie: Cookie of the acknowledged sample.

    If no cookie was provided when writing the sample, the cookie field will be an empty (zero-sized) cookie.
    See also: DDS.Cookie_t

    Valid_Response_Data: Flag indicating validity of the user response data in the acknowledgment

    This flag is true when the DDS.RtpsReliableReaderProtocol_t.min_app_ack_response_keep_duration has not yet elapsed for the acknowledgment's response data.

    The flag is false when that duration has elapsed for the response data.

    Response_Data: User data payload of application-level acknowledgment message

    Response data set by DDS.DataReader when sample was acknowledged.

    AcknowledgmentInfo_Access

    type AcknowledgmentInfo_Access is access all AcknowledgmentInfo;

    PublisherQos_Access

    type PublisherQos_Access is access PublisherQos;

    DataWriterCacheStatus

    type DataWriterCacheStatus is record
          Sample_Count_Peak : aliased Long_Long;
          Sample_Count      : aliased Long_Long;
       end record;

    Summary: <<ext>> The status of the writer's cache.

    Entity:
    DDS.DataWriter

    sample_count_peak: Highest number of samples in the writer's queue over the lifetime of the writer.

    sample_count: Number of samples in the writer's queue, including unregister and dispose samples.

    DataWriterProtocolStatus

    type DataWriterProtocolStatus is record
          Pushed_Sample_Count                                  : aliased DDS.Long_Long := 0;
          Pushed_Sample_Count_Change                           : aliased DDS.Long_Long := 0;
          Pushed_Sample_Bytes                                  : aliased DDS.Long_Long := 0;
          Pushed_Sample_Bytes_Change                           : aliased DDS.Long_Long := 0;
          Filtered_Sample_Count                                : aliased DDS.Long_Long := 0;
          Filtered_Sample_Count_Change                         : aliased DDS.Long_Long := 0;
          Filtered_Sample_Bytes                                : aliased DDS.Long_Long := 0;
          Filtered_Sample_Bytes_Change                         : aliased DDS.Long_Long := 0;
          Sent_Heartbeat_Count                                 : aliased DDS.Long_Long := 0;
          Sent_Heartbeat_Count_Change                          : aliased DDS.Long_Long := 0;
          Sent_Heartbeat_Bytes                                 : aliased DDS.Long_Long := 0;
          Sent_Heartbeat_Bytes_Change                          : aliased DDS.Long_Long := 0;
          Pulled_Sample_Count                                  : aliased DDS.Long_Long := 0;
          Pulled_Sample_Count_Change                           : aliased DDS.Long_Long := 0;
          Pulled_Sample_Bytes                                  : aliased DDS.Long_Long := 0;
          Pulled_Sample_Bytes_Change                           : aliased DDS.Long_Long := 0;
          Received_Ack_Count                                   : aliased DDS.Long_Long := 0;
          Received_Ack_Count_Change                            : aliased DDS.Long_Long := 0;
          Received_Ack_Bytes                                   : aliased DDS.Long_Long := 0;
          Received_Ack_Bytes_Change                            : aliased DDS.Long_Long := 0;
          Received_Nack_Count                                  : aliased DDS.Long_Long := 0;
          Received_Nack_Count_Change                           : aliased DDS.Long_Long := 0;
          Received_Nack_Bytes                                  : aliased DDS.Long_Long := 0;
          Received_Nack_Bytes_Change                           : aliased DDS.Long_Long := 0;
          Sent_Gap_Count                                       : aliased DDS.Long_Long := 0;
          Sent_Gap_Count_Change                                : aliased DDS.Long_Long := 0;
          Sent_Gap_Bytes                                       : aliased DDS.Long_Long := 0;
          Sent_Gap_Bytes_Change                                : aliased DDS.Long_Long := 0;
          Rejected_Sample_Count                                : aliased DDS.Long_Long := 0;
          Rejected_Sample_Count_Change                         : aliased DDS.Long_Long := 0;
          Send_Window_Size                                     : aliased DDS.Long := 0;
          First_Available_Sample_Sequence_Number               : aliased DDS.SequenceNumber_T;
          Last_Available_Sample_Sequence_Number                : aliased DDS.SequenceNumber_T;
          First_Unacknowledged_Sample_Sequence_Number          : aliased DDS.SequenceNumber_T;
          First_Available_Sample_Virtual_Sequence_Number       : aliased DDS.SequenceNumber_T;
          Last_Available_Sample_Virtual_Sequence_Number        : aliased DDS.SequenceNumber_T;
          First_Unacknowledged_Sample_Virtual_Sequence_Number  : aliased DDS.SequenceNumber_T;
          First_Unacknowledged_Sample_Subscription_Handle      : aliased DDS.InstanceHandle_T;
          First_Unelapsed_Keep_Duration_Sample_Sequence_Number : aliased DDS.SequenceNumber_T;
       end record;
    NOTE: filtered_sample_* fields have been removed from the documentation (see CORE-5977) and may eventually be removed from this structure (CORE-5953)

    RequestedDeadlineMissedStatus

    type RequestedDeadlineMissedStatus is record
          Total_Count          : aliased Long := 0;
          Total_Count_Change   : aliased Long := 0;
          Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record;

    Total_Count: Total cumulative count of the deadlines detected for any instance read by the DDS.DataReader.

    Total_Count_Change: The incremental number of deadlines detected since the last time the listener was called or the status was read.

    Last_Instance_Handle: Handle to the last instance in the DDS.DataReader for which a deadline was detected.

    LivelinessChangedStatus

    type LivelinessChangedStatus is record
          Alive_Count             : aliased Long := 0;
          Not_Alive_Count         : aliased Long := 0;
          Alive_Count_Change      : aliased Long := 0;
          Not_Alive_Count_Change  : aliased Long := 0;
          Last_Publication_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record;

    The DDS.DataReaderListener.on_liveliness_changed callback may be invoked for the following reasons:

    • Liveliness is truly lost - a sample has not been received within the timeframe specified in DDS.LivelinessQosPolicy.lease_duration
    • Liveliness is recovered after being lost.
    • A new matching entity has been discovered.
    • A QoS has changed such that a pair of matching entities are no longer matching (such as a change to the DDS.PartitionQosPolicy). In this case, RTI Connext will no longer keep track of the entities' liveliness. Furthermore:
      • If liveliness was maintained: DDS.LivelinessChangedStatus.alive_count will decrease and DDS.LivelinessChangedStatus.not_alive_count will remain the same.
      • If liveliness had been lost: DDS.LivelinessChangedStatus.alive_count will remain the same and DDS.LivelinessChangedStatus.not_alive_count will decrease.

    Alive_Count: The total count of currently alive DDS.DataWriter entities that write the DDS.Topic the DDS.DataReader reads.

    Not_Alive_Count: The total count of currently not_alive DDS.DataWriter entities that write the DDS.Topic the DDS.DataReader reads.

    Alive_Count_Change: The change in the alive_count since the last time the listener was called or the status was read.

    Not_Alive_Count_Change: The change in the not_alive_count since the last time the listener was called or the status was read.

    Last_Publication_Handle: An instance handle to the last remote writer to change its liveliness.

    RequestedIncompatibleQosStatus

    type RequestedIncompatibleQosStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
          Last_Policy_Id     : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID;
          Policies           : aliased QosPolicyCount_Seq.Sequence;
       end record;


    See also: DDSDurabilityQosModule
    See also: DDSPresentationQosModule
    See also: DDSReliabilityQosModule
    See also: DDSOwnershipQosModule
    See also: DDSLivelinessQosModule
    See also: DDSDeadlineQosModule
    See also: DDSLatencyBudgetQosModule
    See also: DDSDestinationOrderQosModule

    Total_Count: Total cumulative count of how many times the concerned DDS.DataReader discovered a DDS.DataWriter for the same DDS.Topic with an offered QoS that is incompatible with that requested by the DDS.DataReader.

    Total_Count_Change: The change in total_count since the last time the listener was called or the status was read.

    Last_Policy_Id: The PolicyId_t of one of the policies that was found to be incompatible the last time an incompatibility was detected.

    Policies: A list containing, for each policy, the total number of times that the concerned DDS.DataReader discovered a DDS.DataWriter for the same DDS.Topic with an offered QoS that is incompatible with that requested by the DDS.DataReader.

    RequestedIncompatibleQosStatus_Access

    type RequestedIncompatibleQosStatus_Access is access all RequestedIncompatibleQosStatus;

    SampleLostStatusKind

    type SampleLostStatusKind is new Unsigned_Long;

    Summary: <<ext>> Kinds of reasons why a sample was lost.

    SampleLostStatus

    type SampleLostStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
          Last_Reason        : aliased SampleLostStatusKind := NOT_LOST;
       end record;

    Total_Count: Total cumulative count of all samples lost across all instances of data published under the DDS.Topic.

    Total_Count_Change: The incremental number of samples lost since the last time the listener was called or the status was read.

    Last_Reason: <<ext>> Reason why the last sample was lost.


    See also: DDS.SampleLostStatusKind

    SampleRejectedStatusKind

    type SampleRejectedStatusKind is
         (NOT_REJECTED,
          REJECTED_BY_INSTANCES_LIMIT,
          REJECTED_BY_SAMPLES_LIMIT,
          REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT,
          REJECTED_BY_REMOTE_WRITERS_LIMIT,
          REJECTED_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT,
          REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT,
          REJECTED_BY_VIRTUAL_WRITERS_LIMIT,
          REJECTED_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT,
          REJECTED_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT);

    Summary: Kinds of reasons for rejecting a sample.

    NOT_REJECTED: Samples are never rejected.


    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_INSTANCES_LIMIT: A resource limit on the number of instances was reached.


    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_SAMPLES_LIMIT: A resource limit on the number of samples was reached.


    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT: A resource limit on the number of samples per instance was reached.


    See also: ResourceLimitsQosPolicy

    REJECTED_BY_REMOTE_WRITERS_LIMIT: A resource limit on the number of remote writers from which a DDS.DataReader may read was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT: A resource limit on the number of remote writers for a single instance from which a DDS.DataReader may read was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT: A resource limit on the number of samples from a given remote writer that a DDS.DataReader may store was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_VIRTUAL_WRITERS_LIMIT: A resource limit on the number of virtual writers from which a DDS.DataReader may read was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    REJECTED_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT: A resource limit on the number of remote writers per sample was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    Summary: A resource limit on the number of samples published by a remote writer on behalf of a virtual writer that a DDS.DataReader may store was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    SampleRejectedStatus

    type SampleRejectedStatus is record
          Total_Count          : aliased Long := 0;
          Total_Count_Change   : aliased Long := 0;
          Last_Reason          : aliased SampleRejectedStatusKind := NOT_REJECTED;
          Last_Instance_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record;

    Total_Count: Total cumulative count of samples rejected by the DDS.DataReader.

    Total_Count_Change: The incremental number of samples rejected since the last time the listener was called or the status was read.

    Last_Reason: Reason for rejecting the last sample rejected.


    See also: DDS.SampleRejectedStatusKind

    Last_Instance_Handle: Handle to the instance being updated by the last sample that was rejected.

    SubscriptionMatchedStatus

    type SubscriptionMatchedStatus is limited record
          Total_Count             : aliased Long := 0;
          Total_Count_Change      : aliased Long := 0;
          Current_Count           : aliased Long := 0;
          Current_Count_Peak      : aliased Long := 0;
          Current_Count_Change    : aliased Long := 0;
          Last_Publication_Handle : aliased InstanceHandle_T := Null_InstanceHandle_T;
       end record;

    Summary: DDS.SUBSCRIPTION_MATCHED_STATUS

    A "match" happens when the DDS.DataReader finds a DDS.DataWriter for the same DDS.Topic with an offered QoS that is compatible with that requested by the DDS.DataReader.

    This status is also changed (and the listener, if any, called) when a match is ended. A local DDS.DataReader will become "unmatched" from a remote DDS.DataWriter when that DDS.DataWriter goes away for any reason.

    Total_Count: The total cumulative number of times the concerned DDS.DataReader discovered a "match" with a DDS.DataWriter.

    This number increases whenever a new match is discovered. It does not change when an existing match goes away.

    Total_Count_Change: The change in total_count since the last time the listener was called or the status was read.

    Current_Count: The current number of writers with which the DDS.DataReader is matched.

    This number increases when a new match is discovered and decreases when an existing match goes away.

    Current_Count_Peak: <<ext>> The highest value that current_count has reached until now.

    Current_Count_Change: The change in current_count since the last time the listener was called or the status was read.

    Last_Publication_Handle: A handle to the last DDS.DataWriter that caused the status to change.

    DataReaderCacheStatus

    type DataReaderCacheStatus is record
          Sample_Count_Peak : aliased Long_Long := 0;
          Sample_Count      : aliased Long_Long := 0;
       end record;

    Summary: <<ext>> The status of the reader's cache.

    Entity:
    DDS.DataReader

    Sample_Count_Peak: The highest number of samples in the reader's queue over the lifetime of the reader.

    Sample_Count: The number of samples in the reader's queue.

    includes samples that may not yet be available to be read or taken by the user, due to samples being received out of order or DDSPresentationQosModule

    DataReaderProtocolStatus

    type DataReaderProtocolStatus is record
          Received_Sample_Count                  : aliased Long_Long := 0;
          Received_Sample_Count_Change           : aliased Long_Long := 0;
          Received_Sample_Bytes                  : aliased Long_Long := 0;
          Received_Sample_Bytes_Change           : aliased Long_Long := 0;
          Duplicate_Sample_Count                 : aliased Long_Long := 0;
          Duplicate_Sample_Count_Change          : aliased Long_Long := 0;
          Duplicate_Sample_Bytes                 : aliased Long_Long := 0;
          Duplicate_Sample_Bytes_Change          : aliased Long_Long := 0;
          Filtered_Sample_Count                  : aliased Long_Long := 0;
          Filtered_Sample_Count_Change           : aliased Long_Long := 0;
          Filtered_Sample_Bytes                  : aliased Long_Long := 0;
          Filtered_Sample_Bytes_Change           : aliased Long_Long := 0;
          Received_Heartbeat_Count               : aliased Long_Long := 0;
          Received_Heartbeat_Count_Change        : aliased Long_Long := 0;
          Received_Heartbeat_Bytes               : aliased Long_Long := 0;
          Received_Heartbeat_Bytes_Change        : aliased Long_Long := 0;
          Sent_Ack_Count                         : aliased Long_Long := 0;
          Sent_Ack_Count_Change                  : aliased Long_Long := 0;
          Sent_Ack_Bytes                         : aliased Long_Long := 0;
          Sent_Ack_Bytes_Change                  : aliased Long_Long := 0;
          Sent_Nack_Count                        : aliased Long_Long := 0;
          Sent_Nack_Count_Change                 : aliased Long_Long := 0;
          Sent_Nack_Bytes                        : aliased Long_Long := 0;
          Sent_Nack_Bytes_Change                 : aliased Long_Long := 0;
          Received_Gap_Count                     : aliased Long_Long := 0;
          Received_Gap_Count_Change              : aliased Long_Long := 0;
          Received_Gap_Bytes                     : aliased Long_Long := 0;
          Received_Gap_Bytes_Change              : aliased Long_Long := 0;
          Rejected_Sample_Count                  : aliased Long_Long := 0;
          Rejected_Sample_Count_Change           : aliased Long_Long := 0;
          First_Available_Sample_Sequence_Number : aliased SequenceNumber_T;
          Last_Available_Sample_Sequence_Number  : aliased SequenceNumber_T;
          Last_Committed_Sample_Sequence_Number  : aliased SequenceNumber_T;
          Uncommitted_Sample_Count               : aliased Long := 0;
       end record;

    Summary: <<ext>> The status of a reader's internal protocol related metrics, like the number of samples received, filtered, rejected; and status of wire protocol traffic.

    Entity:
    DDS.DataReader

    received_sample_count: The number of samples received by a DataReader.

    Depending on how the DDS.DataReaderProtocolStatus was obtained this may count samples coming from a specific DataWriter or from all the DataWriters that are matched with the DataReader.

    If the DDS.DataReaderProtocolStatus is obtained using the DDS.DataReader.get_datareader_protocol_status operation then it will count samples from any DataWriter. If the DataReaderProtocolStatus is obtained using the DDS.DataReader.get_matched_publication_datareader_protocol_status then it will count the samples for the DataWriter specified as a parameter to the function.

    Duplicate samples arriving from the DataWriter(s) (e.g. via multiple network paths) are detected prior to increasing this counter. The duplicate samples are counted by DDS.DataReaderProtocolStatus.duplicate_sample_count.

    If the DataReader has specified a ContentFilter the received samples that do not pass the filter are part of this counter. The filtered samples are counted by DDS.DataReaderProtocolStatus.filtered_sample_count.

    Samples rejected because they do not fit on the DataReader Queue are also part of this counter.

    Note the received_sample_count counts samples received from all DataWriters and it does not necessarily match the number of samples accepted into the DataReader Queue. This is because:

  • Samples can also be inserted into the DataReader Queue by lifecycle events that are locally detected like an instance becoming not alive as a result of DataWriters leaving the network.
  • Samples can be filtered out due to ContentFilter or TimeFilter
  • Samples can be rejected because there is no space in DataReader Queue

    received_sample_count_change: The incremental change in the number of samples received from a DataReader since the last time the status was read.


    See also: DDS.DataReaderProtocolStatus.received_sample_count

    received_sample_bytes: The number of bytes received by a DataReader.


    See also: DDS.DataReaderProtocolStatus.received_sample_count

    received_sample_bytes_change: The incremental change in the number of bytes received from a DataReader since the last time the status was read.


    See also: DDS.DataReaderProtocolStatus.received_sample_count_change

    duplicate_sample_count: The number of samples from a remote DataWriter received, not for the first time, by a local DataReader.

    Such samples can be redundant, out-of-order, etc. and are not stored in the reader's queue.

    duplicate_sample_count_change: The incremental change in the number of samples from a remote DataWriter received, not for the first time, by a local DataReader since the last time the status was read.

    Such samples can be redundant, out-of-order, etc. and are not stored in the reader's queue.

    duplicate_sample_bytes: The number of bytes of samples from a remote DataWriter received, not for the first time, by a local DataReader.

    Such samples can be redundant, out-of-order, etc. and are not stored in the reader's queue.

    duplicate_sample_bytes_change: The incremental change in the number of bytes of samples from a remote DataWriter received, not for the first time, by a local DataReader since the last time the status was read.

    Such samples can be redundant, out-of-order, etc. and are not stored in the reader's queue.

    filtered_sample_count: The number of user samples filtered by the local DataReader due to Content-Filtered Topics or Time-Based Filter.

    filtered_sample_count_change: The incremental change in the number of user samples filtered by the local DataReader due to Content-Filtered Topics or Time-Based Filter since the last time the status was read.

    filtered_sample_bytes: The number of bytes of user samples filtered by the local DataReader due to Content-Filtered Topics or Time-Based Filter.

    filtered_sample_bytes_change: The incremental change in the number of bytes of user samples filtered by the local DataReader due to Content-Filtered Topics or Time-Based Filter since the last time the status was read.

    received_heartbeat_count: The number of Heartbeats from a remote DataWriter received by a local DataReader.

    received_heartbeat_count_change: The incremental change in the number of Heartbeats from a remote DataWriter received by a local DataReader since the last time the status was read.

    received_heartbeat_bytes: The number of bytes of Heartbeats from a remote DataWriter received by a local DataReader.

    received_heartbeat_bytes_change: The incremental change in the number of bytes of Heartbeats from a remote DataWriter received by a local DataReader since the last time the status was read.

    sent_ack_count: The number of ACKs sent from a local DataReader to a matching remote DataWriter.

    sent_ack_count_change: The incremental change in the number of ACKs sent from a local DataReader to a matching remote DataWriter since the last time the status was read.

    sent_ack_bytes: The number of bytes of ACKs sent from a local DataReader to a matching remote DataWriter.

    sent_ack_bytes_change: The incremental change in the number of bytes of ACKs sent from a local DataReader to a matching remote DataWriter since the last time the status was read.

    sent_nack_count: The number of NACKs sent from a local DataReader to a matching remote DataWriter.

    sent_nack_count_change: The incremental change in the number of NACKs sent from a local DataReader to a matching remote DataWriter since the last time the status was read.

    sent_nack_bytes: The number of bytes of NACKs sent from a local DataReader to a matching remote DataWriter.

    sent_nack_bytes_change: The incremental change in the number of bytes of NACKs sent from a local DataReader to a matching remote DataWriter since the last time the status was read.

    received_gap_count: The number of GAPs received from remote DataWriter to this DataReader.

    received_gap_count_change: The incremental change in the number of GAPs received from remote DataWriter to this DataReader since the last time the status was read.

    received_gap_bytes: The number of bytes of GAPs received from remote DataWriter to this DataReader.

    received_gap_bytes_change: The incremental change in the number of bytes of GAPs received from remote DataWriter to this DataReader since the last time the status was read.

    rejected_sample_count: The number of times a sample is rejected due to exceptions in the receive path.

    rejected_sample_count_change: The incremental change in the number of times a sample is rejected due to exceptions in the receive path since the last time the status was read.

    first_available_sample_sequence_number: Sequence number of the first available sample in a matched DataWriters reliability queue.

    Applicable only for reliable DataReaders, and when retrieving matched DataWriter statuses.

    Updated upon receiving Heartbeat submessages from a matched reliable DataWriter.

    last_available_sample_sequence_number: Sequence number of the last available sample in a matched Datawriter's reliability queue.

    Applicable only for reliable DataReaders, and when retrieving matched DataWriter statuses.

    Updated upon receiving Heartbeat submessages from a matched reliable DataWriter.

    last_committed_sample_sequence_number: Sequence number of the newest sample received from the matched DataWriter committed to the DataReader's queue.

    Applicable only when retrieving matched DataWriter statuses.

    For best-effort DataReaders, this is the sequence number of the latest sample received.

    For reliable DataReaders, this is the sequence number of the latest sample that is available to be read or taken from the DataReader's queue.

    uncommitted_sample_count: Number of received samples that are not yet available to be read or taken, due to being received out of order.

    Applicable only when retrieving matched DataWriter statuses.

  • SampleStateKind

    type SampleStateKind is new Unsigned_Long;

    Summary: Indicates whether or not a sample has ever been read.

    For each sample received, the middleware internally maintains a sample_state relative to each DDS.DataReader. The sample state can be either:

  • DDS.READ_SAMPLE_STATE indicates that the DDS.DataReader has already accessed that sample by means of a read or take operation.

  • DDS.NOT_READ_SAMPLE_STATE indicates that the DDS.DataReader has not accessed that sample before.

    The sample state will, in general, be different for each sample in the collection returned by read or take.

  • SampleStateMask

    subtype SampleStateMask is SampleStateKind;

    Summary: A bit-mask (list) of sample states, i.e. DDS.SampleStateKind.

    SampleStateKind_Access

    type SampleStateKind_Access is access constant SampleStateKind;

    ViewStateKind

    type ViewStateKind is new Unsigned_Long;

    Summary: Indicates whether or not an instance is new.

    For each instance (identified by the key), the middleware internally maintains a view state relative to each DDS.DataReader. The view state can be either:

  • DDS.NEW_VIEW_STATE indicates that either this is the first time that the DDS.DataReader has ever accessed samples of that instance, or else that the DDS.DataReader has accessed previous samples of the instance, but the instance has since been reborn (i.e. become not-alive and then alive again). These two cases are distinguished by examining the DDS.SampleInfo.disposed_generation_count and the DDS.SampleInfo.no_writers_generation_count.

  • DDS.NOT_NEW_VIEW_STATE indicates that the DDS.DataReader has already accessed samples of the same instance and that the instance has not been reborn since.

    The view_state available in the DDS.SampleInfo is a snapshot of the view state of the instance relative to the DDS.DataReader used to access the samples at the time the collection was obtained (i.e. at the time read or take was called). The view_state is therefore the same for all samples in the returned collection that refer to the same instance.

    Once an instance has been detected as not having any "live" writers and all the samples associated with the instance are "taken" from the DDS.DataReader, the middleware can reclaim all local resources regarding the instance. Future samples will be treated as "never seen."

  • ViewStateMask

    subtype ViewStateMask is ViewStateKind;

    Summary: A bit-mask (list) of view states, i.e. DDS.ViewStateKind.

    ViewStateKind_Access

    type ViewStateKind_Access is access constant ViewStateKind;

    InstanceStateKind

    type InstanceStateKind is   new Unsigned_Long;

    Summary: Indicates if the samples are from a live DDS.DataWriter or not.

    For each instance, the middleware internally maintains an instance state. The instance state can be:

  • DDS.ALIVE_INSTANCE_STATE indicates that (a) samples have been received for the instance, (b) there are live DDS.DataWriter entities writing the instance, and (c) the instance has not been explicitly disposed (or else more samples have been received after it was disposed).

  • DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE indicates the instance was explicitly disposed by a DDS.DataWriter by means of the dispose operation.

  • DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE indicates the instance has been declared as not-alive by the DDS.DataReader because it detected that there are no live DDS.DataWriter entities writing that instance.

    The precise behavior events that cause the instance state to change depends on the setting of the OWNERSHIP QoS:

  • If DDSOwnershipQosModule is set to DDS.EXCLUSIVE_OWNERSHIP_QOS, then the instance state becomes DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE only if the DDS.DataWriter that "owns" the instance explicitly disposes it. The instance state becomes DDS.ALIVE_INSTANCE_STATE again only if the DDS.DataWriter that owns the instance writes it.

  • If DDSOwnershipQosModule is set to DDS.SHARED_OWNERSHIP_QOS, then the instance state becomes DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE if any DDS.DataWriter explicitly disposes the instance. The instance state becomes DDS.ALIVE_INSTANCE_STATE as soon as any DDS.DataWriter writes the instance again.

    The instance state available in the DDS.SampleInfo is a snapshot of the instance state of the instance at the time the collection was obtained (i.e. at the time read or take was called). The instance state is therefore the same for all samples in the returned collection that refer to the same instance.

  • InstanceStateMask

    subtype InstanceStateMask is InstanceStateKind;

    Summary: A bit-mask (list) of instance states, i.e. DDS.InstanceStateKind.

    InstanceStateKind_Access

    type InstanceStateKind_Access is access constant InstanceStateKind;

    SampleInfo

    type SampleInfo is record
          Sample_State                                                : aliased SampleStateKind;
          View_State                                                  : aliased ViewStateKind;
          Instance_State                                              : aliased InstanceStateKind;
          Source_Timestamp                                            : aliased Time_T;
          Instance_Handle                                             : aliased InstanceHandle_T;
          Publication_Handle                                          : aliased InstanceHandle_T;
          Disposed_Generation_Count                                   : aliased Long := 0;
          No_Writers_Generation_Count                                 : aliased Long := 0;
          Sample_Rank                                                 : aliased Long := 0;
          Generation_Rank                                             : aliased Long := 0;
          Absolute_Generation_Rank                                    : aliased Long := 0;
          Valid_Data                                                  : aliased DDS.Boolean := False;
          Reception_Timestamp                                         : aliased Time_T;
          Publication_Sequence_Number                                 : aliased SequenceNumber_T;
          Reception_Sequence_Number                                   : aliased SequenceNumber_T;
          Publication_Virtual_Guid                                    : aliased Guid_T;
          Publication_Virtual_Sequence_Number                         : aliased SequenceNumber_T;
          Original_Publication_Virtual_Guid                           : aliased Guid_T;
          Original_Publication_Virtual_Sequence_Number                : aliased SequenceNumber_T;
          Related_Original_Publication_Virtual_Guid                   : aliased Guid_T;
          Related_Original_Publication_Virtual_Sequence_Number        : aliased SequenceNumber_T;
          Flag                                                        : aliased SampleFlag;
          Source_Guid                                                 : aliased Guid_T;
          Related_Source_Guid                                         : aliased Guid_T;
          Related_Subscription_Guid                                   : aliased Guid_T;
          Topic_Query_Guid                                            : aliased Guid_T;
          Sample_Info_Hash                                            : aliased RTIDDS.Low_Level.osapi.hash_h.RTIOsapiHash;
          Sample_Signature                                            : aliased RTIDDS.Low_Level.pres.common_impl_h.PRESSampleSignature;
       end record;

    Summary: Information that accompanies each sample that is read or taken.

    Interpretation of the SampleInfo

    The DDS.SampleInfo contains information pertaining to the associated Data instance sample including:

    • the sample_state of the Data value (i.e., if it has already been read or not)
    • the view_state of the related instance (i.e., if the instance is new or not)
    • the instance_state of the related instance (i.e., if the instance is alive or not)
    • DDS.SampleInfo.valid_data flag. This flag indicates whether there is data associated with the sample. Some samples do not contain data indicating only a change on the instance_state of the corresponding instance.
    • The values of disposed_generation_count and no_writers_generation_count for the related instance at the time the sample was received. These counters indicate the number of times the instance had become ALIVE (with instance_state= DDS.ALIVE_INSTANCE_STATE) at the time the sample was received.
    • The sample_rank and generation_rank of the sample within the returned sequence. These ranks provide a preview of the samples that follow within the sequence returned by the read or take operations.
    • The absolute_generation_rank of the sample within the DDS.DataReader. This rank provides a preview of what is available within the DDS.DataReader.
    • The source_timestamp of the sample. This is the timestamp provided by the DDS.DataWriter at the time the sample was produced.

    Interpretation of the SampleInfo disposed_generation_count and no_writers_generation_count

    For each instance, RTI Connext internally maintains two counts, the DDS.SampleInfo.disposed_generation_count and DDS.SampleInfo.no_writers_generation_count, relative to each DataReader:

  • The DDS.SampleInfo.disposed_generation_count and DDS.SampleInfo.no_writers_generation_count are initialized to zero when the DDS.DataReader first detects the presence of a never-seen-before instance.

  • The DDS.SampleInfo.disposed_generation_count is incremented each time the instance_state of the corresponding instance changes from DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE to DDS.ALIVE_INSTANCE_STATE.

  • The DDS.SampleInfo.no_writers_generation_count is incremented each time the instance_state of the corresponding instance changes from DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE to DDS.ALIVE_INSTANCE_STATE.

  • These 'generation counts' are reset to zero when the instance resource is reclaimed.

    The DDS.SampleInfo.disposed_generation_count and DDS.SampleInfo.no_writers_generation_count available in the DDS.SampleInfo capture a snapshot of the corresponding counters at the time the sample was received.

    Interpretation of the SampleInfo sample_rank, generation_rank and absolute_generation_rank

    The DDS.SampleInfo.sample_rank and DDS.SampleInfo.generation_rank available in the DDS.SampleInfo are computed based solely on the actual samples in the ordered collection returned by read or take.

  • The DDS.SampleInfo.sample_rank indicates the number of samples of the same instance that follow the current one in the collection.

  • The DDS.SampleInfo.generation_rank available in the DDS.SampleInfo indicates the difference in "generations" between the sample (S) and the Most Recent Sample of the same instance that appears in the returned Collection (MRSIC). That is, it counts the number of times the instance transitioned from not-alive to alive in the time from the reception of the S to the reception of MRSIC.

  • These 'generation ranks' are reset to zero when the instance resource is reclaimed.

    The DDS.SampleInfo.generation_rank is computed using the formula:

    generation_rank = (MRSIC.disposed_generation_count
                             + MRSIC.no_writers_generation_count)
                       - (S.disposed_generation_count
                             + S.no_writers_generation_count)                

    The DDS.SampleInfo.absolute_generation_rank available in the DDS.SampleInfo indicates the difference in "generations" between the sample (S) and the Most Recent Sample of the same instance that the middleware has received (MRS). That is, it counts the number of times the instance transitioned from not-alive to alive in the time from the reception of the S to the time when the read or take was called.

    absolute_generation_rank = (MRS.disposed_generation_count
                                     + MRS.no_writers_generation_count)
                                - (S.disposed_generation_count
                                     + S.no_writers_generation_count)                

    Interpretation of the SampleInfo counters and ranks

    These counters and ranks allow the application to distinguish samples belonging to different "generations" of the instance. Note that it is possible for an instance to transition from not-alive to alive (and back) several times before the application accesses the data by means of read or take. In this case, the returned collection may contain samples that cross generations (i.e. some samples were received before the instance became not-alive, other after the instance re-appeared again). Using the information in the DDS.SampleInfo, the application can anticipate what other information regarding the same instance appears in the returned collection, as well as in the infrastructure and thus make appropriate decisions.

    For example, an application desiring to only consider the most current sample for each instance would only look at samples with sample_rank == 0. Similarly, an application desiring to only consider samples that correspond to the latest generation in the collection will only look at samples with generation_rank == 0. An application desiring only samples pertaining to the latest generation available will ignore samples for which absolute_generation_rank != 0. Other application-defined criteria may also be used.


    See also: DDS.SampleStateKind, DDS.InstanceStateKind, DDS.ViewStateKind, DDS.SampleInfo.valid_data


    Statechart of the instance_state and view_state of a single instance

    Sample_State: The sample state of the sample.

    Indicates whether or not the corresponding data sample has already been read.


    See also: DDS.SampleStateKind

    View_State: The view state of the instance.

    Indicates whether the DDS.DataReader has already seen samples for the most-current generation of the related instance.


    See also: DDS.ViewStateKind

    Instance_State: The instance state of the instance.

    Indicates whether the instance is currently in existence or, if it has been disposed, the reason why it was disposed.


    See also: DDS.InstanceStateKind

    Source_Timestamp: The timestamp when the sample was written by a DataWriter.

    Instance_Handle: Identifies locally the corresponding instance.

    Publication_Handle: Identifies locally the DataWriter that modified the instance.

    The publication_handle is the same DDS.InstanceHandle_t that is returned by the operation DDS.DataReader.get_matched_publications and can also be used as a parameter to the operation DDS.DataReader.get_matched_publication_data.

    Disposed_Generation_Count: The disposed generation count of the instance at the time of sample reception.

    Indicates the number of times the instance had become alive after it was disposed explicitly by a DDS.DataWriter, at the time the sample was received.


    See also: Interpretation_generation_count Interpretation_counters_ranks

    No_Writers_Generation_Count: The no writers generation count of the instance at the time of sample reception.

    Indicates the number of times the instance had become alive after it was disposed because there were no writers, at the time the sample was received.


    See also: Interpretation_generation_count Interpretation_counters_ranks

    Sample_Rank: The sample rank of the sample.

    Indicates the number of samples related to the same instance that follow in the collection returned by read or take.


    See also: Interpretation_rank Interpretation_counters_ranks

    Generation_Rank: The generation rank of the sample.

    Indicates the generation difference (number of times the instance was disposed and become alive again) between the time the sample was received, and the time the most recent sample in the collection related to the same instance was received.


    See also: Interpretation_rank Interpretation_counters_ranks

    Absolute_Generation_Rank: The absolute generation rank of the sample.

    Indicates the generation difference (number of times the instance was disposed and become alive again) between the time the sample was received, and the time the most recent sample (which may not be in the returned collection) related to the same instance was received.


    See also: Interpretation_rank Interpretation_counters_ranks

    Valid_Data: Indicates whether the DataSample contains data or else it is only used to communicate a change in the instance_state of the instance

    Normally each DataSample contains both a DDS.SampleInfo and some Data. However there are situations where a DataSample contains only the DDS.SampleInfo and does not have any associated data. This occurs when the RTI Connext notifies the application of a change of state for an instance that was caused by some internal mechanism (such as a timeout) for which there is no associated data. An example of this situation is when the RTI Connext detects that an instance has no writers and changes the corresponding instance_state to DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE.

    The application can distinguish whether a particular DataSample has data by examining the value of the DDS.SampleInfo.valid_data. If this flag is set to DDS.BOOLEAN_TRUE, then the DataSample contains valid Data. If the flag is set to DDS.BOOLEAN_FALSE, the DataSample contains no Data.

    To ensure correctness and portability, the valid_data flag must be examined by the application prior to accessing the Data associated with the DataSample and if the flag is set to DDS.BOOLEAN_FALSE, the application should not access the Data associated with the DataSample, that is, the application should access only the DDS.SampleInfo.

    Reception_Timestamp: <<ext>> The timestamp when the sample was committed by a DataReader.

    Publication_Sequence_Number: <<ext>> The publication sequence number.

    Reception_Sequence_Number: <<ext>> The reception sequence number when sample was committed by a DataReader

    Original_Publication_Virtual_Guid: <<ext>> The original publication virtual GUID.

    If the DDS.PresentationQosPolicy::access_scope of the DDS.Publisher is DDS.GROUP_PRESENTATION_QOS, this field contains the DDS.Publisher virtual GUID that uniquely identifies the DataWriter group.

    Original_Publication_Virtual_Sequence_Number: <<ext>> The original publication virtual sequence number.

    If the DDS.PresentationQosPolicy::access_scope of the DDS.Publisher is DDS.GROUP_PRESENTATION_QOS, this field contains the DDS.Publisher virtual sequence number that uniquely identifies a sample within the DataWriter group.

    Related_Original_Publication_Virtual_Guid: <<ext>> The original publication virtual GUID of a related sample.

    Related_Original_Publication_Virtual_Sequence_Number: <<ext>> The original publication virtual sequence number of a related sample.

    Flag: <<ext>> Flags associated with the sample.

    The flags can be set by using the field DDS_WriteParams_t.flag when writing a sample using the procedure FooDataWriter.write_w_params.

    Source_Guid: <<ext>> The application logical data source associated with the sample.

    The source_guid can be set by using the field DDS_WriteParams_t.source_guid when writing a sample using the procedure FooDataWriter.write_w_params.

    Related_Source_Guid: <<ext>> The application logical data source that is related to the sample.

    The related_source_guid can be set by using the field DDS_WriteParams_t.related_source_guid when writing a sample using the procedure FooDataWriter.write_w_params.

    Related_Subscription_Guid: <<ext>> The related_reader_guid associated with the sample.

    The related_reader_guid can be set by using the field DDS_WriteParams_t.related_reader_guid when writing a sample using the procedure FooDataWriter.write_w_params.

  • SampleInfo_Access

    type SampleInfo_Access is access all SampleInfo;

    SampleInfo_Array

    type SampleInfo_Array is array (Natural range <>) of aliased SampleInfo;

    SubscriberQos_Access

    type SubscriberQos_Access is access SubscriberQos;

    LoggingQosPolicy

    type LoggingQosPolicy is new DDS_LoggingQosPolicy;

    SqlFilterAlignmentQos

    type SqlFilterAlignmentQos is record
          Char_Alignment       : aliased DDS.Unsigned_Short := 0;
          Short_Alignment      : aliased DDS.Unsigned_Short := 0;
          Long_Alignment       : aliased DDS.Unsigned_Short := 0;
          Float_Alignment      : aliased DDS.Unsigned_Short := 0;
          Double_Alignment     : aliased DDS.Unsigned_Short := 0;
          Longlong_Alignment   : aliased DDS.Unsigned_Short := 0;
          Longdouble_Alignment : aliased DDS.Unsigned_Short := 0;
          Pointer_Alignment    : aliased DDS.Unsigned_Short := 0;
       end record;
    ndds/dds_c/dds_c_sqlfilter.h:170

    SqlFilterMemoryManagementQos

    type SqlFilterMemoryManagementQos is record
          Buffer_Min_Size : aliased DDS.Long;  -- ndds/dds_c/dds_c_sqlfilter.h:198
          Trim_Buffer     : aliased DDS.Boolean;  -- ndds/dds_c/dds_c_sqlfilter.h:199
       end record;

    SqlFilterGeneratorQos

    type SqlFilterGeneratorQos is new RTIDDS.Low_Level.dds_c.sqlfilter_h.DDS_SqlFilterGeneratorQos;
    ndds/dds_c/dds_c_sqlfilter.h:197

    DomainParticipantFactoryQos_Access

    type DomainParticipantFactoryQos_Access is access constant DomainParticipantFactoryQos;

    FlowControllerSchedulingPolicy

    type FlowControllerSchedulingPolicy is new Unsigned_Long;

    Summary: Kinds of flow controller scheduling policy

    Samples written by an asynchronous DDS.DataWriter are not sent in the context of the FooDataWriter.write call. Instead, the middleware puts the samples in a queue for future processing. The DDS.FlowController associated with each asynchronous DataWriter instance determines when the samples are actually sent.

    Each DDS.FlowController maintains a separate FIFO queue for each unique destination (remote application). Samples written by asynchronous DDS.DataWriter instances associated with the flow controller, are placed in the queues that correspond to the intended destinations of the sample.

    When tokens become available, a flow controller must decide which queue(s) to grant tokens first. This is determined by the flow controller's scheduling policy. Once a queue has been granted tokens, it is serviced by the asynchronous publishing thread. The queued up samples will be coalesced and sent to the corresponding destination. The number of samples sent depends on the data size and the number of tokens granted.

    QoS:
    DDS.FlowControllerProperty_t

    Samples written by an asynchronous DDS.DataWriter are not sent in the context of the FooDataWriter.write call. Instead, the middleware puts the samples in a queue for future processing. The DDS.FlowController associated with each asynchronous DataWriter instance determines when the samples are actually sent.

    Each DDS.FlowController maintains a separate FIFO queue for each unique destination (remote application). Samples written by asynchronous DDS.DataWriter instances associated with the flow controller, are placed in the queues that correspond to the intended destinations of the sample.

    When tokens become available, a flow controller must decide which queue(s) to grant tokens first. This is determined by the flow controller's scheduling policy. Once a queue has been granted tokens, it is serviced by the asynchronous publishing thread. The queued up samples will be coalesced and sent to the corresponding destination. The number of samples sent depends on the data size and the number of tokens granted.

    FlowControllerTokenBucketProperty_T

    type FlowControllerTokenBucketProperty_T is record
          Max_Tokens               : aliased DDS.Long := 0;
          Tokens_Added_Per_Period  : aliased DDS.Long := 0;
          Tokens_Leaked_Per_Period : aliased DDS.Long := 0;
          Period                   : aliased Duration_T;
          Bytes_Per_Token          : aliased DDS.Long := 0;
       end record;

    Summary: DDS.FlowController uses the popular token bucket approach for open loop network flow control. The flow control characteristics are determined by the token bucket properties.

    Asynchronously published samples are queued up and transmitted based on the token bucket flow control scheme. The token bucket contains tokens, each of which represents a number of bytes. Samples can be sent only when there are sufficient tokens in the bucket. As samples are sent, tokens are consumed. The number of tokens consumed is proportional to the size of the data being sent. Tokens are replenished on a periodic basis.

    The rate at which tokens become available and other token bucket properties determine the network traffic flow.

    Note that if the same sample must be sent to multiple destinations, separate tokens are required for each destination. Only when multiple samples are destined to the same destination will they be co-alesced and sent using the same token(s). In other words, each token can only contribute to a single network packet.

    Entity:
    DDS.FlowController

    Properties:
    "Rx0" = N/A

    "Changeable" = "YES" . However, the special value of DDS_DURATION_INFINITE as DDS.FlowControllerTokenBucketProperty_t.period is strictly used to create an on-demand DDS.FlowController. The token period cannot toggle from an infinite to finite value (or vice versa). It can, however, change from one finite value to another.

    The number of tokens in the bucket will never exceed this value. Any excess tokens are discarded. This property value, combined with DDS.FlowControllerTokenBucketProperty_t.bytes_per_token, determines the maximum allowable data burst.

    Use DDS.LENGTH_UNLIMITED to allow accumulation of an unlimited amount of tokens (and therefore potentially an unlimited burst size).

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,DDS.LENGTH_UNLIMITED]

    DDS.FlowController transmits data only when tokens are available. Tokens are periodically replenished. This field determines the number of tokens added to the token bucket with each periodic replenishment.

    Available tokens are distributed to associated DDS.DataWriter instances based on the DDS.FlowControllerProperty_t.scheduling_policy.

    Use DDS.LENGTH_UNLIMITED to add the maximum number of tokens allowed by DDS.FlowControllerTokenBucketProperty_t.max_tokens.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,DDS.LENGTH_UNLIMITED]

    DDS.FlowController transmits data only when tokens are available. When tokens are replenished and there are sufficient tokens to send all samples in the queue, this property determines whether any or all of the leftover tokens remain in the bucket.

    Use DDS.LENGTH_UNLIMITED to remove all excess tokens from the token bucket once all samples have been sent. In other words, no token accumulation is allowed. When new samples are written after tokens were purged, the earliest point in time at which they can be sent is at the next periodic replenishment.

    [default] 0

    [range] [0,DDS.LENGTH_UNLIMITED]

    DDS.FlowController transmits data only when tokens are available. This field determines the period by which tokens are added or removed from the token bucket.

    The special value DDS_DURATION_INFINITE can be used to create an on-demand DDS.FlowController, for which tokens are no longer replenished periodically. Instead, tokens must be added explicitly by calling DDS.FlowController.trigger_flow. This external trigger adds DDS.FlowControllerTokenBucketProperty_t.tokens_added_per_period tokens each time it is called (subject to the other property settings).

    [default] 1 second

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE

    DDS.FlowController transmits data only when tokens are available. This field determines the number of bytes that can actually be transmitted based on the number of tokens.

    Tokens are always consumed in whole by each DDS.DataWriter. That is, in cases where DDS.FlowControllerTokenBucketProperty_t.bytes_per_token is greater than the sample size, multiple samples may be sent to the same destination using a single token (regardless of DDS.FlowControllerProperty_t.scheduling_policy).

    Where fragmentation is required, the fragment size will be DDS.FlowControllerTokenBucketProperty_t.bytes_per_token or the minimum largest message size across all transports installed with the DDS.DataWriter, whichever is less.

    Use DDS.LENGTH_UNLIMITED to indicate that an unlimited number of bytes can be transmitted per token. In other words, a single token allows the recipient DDS.DataWriter to transmit all its queued samples to a single destination. A separate token is required to send to each additional destination.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1024,DDS.LENGTH_UNLIMITED]

    max_tokens: Maximum number of tokens than can accumulate in the token bucket.

    The number of tokens in the bucket will never exceed this value. Any excess tokens are discarded. This property value, combined with DDS.FlowControllerTokenBucketProperty_t.bytes_per_token, determines the maximum allowable data burst.

    Use DDS.LENGTH_UNLIMITED to allow accumulation of an unlimited amount of tokens (and therefore potentially an unlimited burst size).

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,DDS.LENGTH_UNLIMITED]

    tokens_added_per_period: The number of tokens added to the token bucket per specified period.

    DDS.FlowController transmits data only when tokens are available. Tokens are periodically replenished. This field determines the number of tokens added to the token bucket with each periodic replenishment.

    Available tokens are distributed to associated DDS.DataWriter instances based on the DDS.FlowControllerProperty_t.scheduling_policy.

    Use DDS.LENGTH_UNLIMITED to add the maximum number of tokens allowed by DDS.FlowControllerTokenBucketProperty_t.max_tokens.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1,DDS.LENGTH_UNLIMITED]

    tokens_leaked_per_period: The number of tokens removed from the token bucket per specified period.

    DDS.FlowController transmits data only when tokens are available. When tokens are replenished and there are sufficient tokens to send all samples in the queue, this property determines whether any or all of the leftover tokens remain in the bucket.

    Use DDS.LENGTH_UNLIMITED to remove all excess tokens from the token bucket once all samples have been sent. In other words, no token accumulation is allowed. When new samples are written after tokens were purged, the earliest point in time at which they can be sent is at the next periodic replenishment.

    [default] 0

    [range] [0,DDS.LENGTH_UNLIMITED]

    period: Period for adding tokens to and removing tokens from the bucket.

    DDS.FlowController transmits data only when tokens are available. This field determines the period by which tokens are added or removed from the token bucket.

    The special value DDS_DURATION_INFINITE can be used to create an on-demand DDS.FlowController, for which tokens are no longer replenished periodically. Instead, tokens must be added explicitly by calling DDS.FlowController.trigger_flow. This external trigger adds DDS.FlowControllerTokenBucketProperty_t.tokens_added_per_period tokens each time it is called (subject to the other property settings).

    [default] 1 second

    [range] [1 nanosec, 1 year] or DDS_DURATION_INFINITE

    bytes_per_token: Maximum number of bytes allowed to send for each token available.

    DDS.FlowController transmits data only when tokens are available. This field determines the number of bytes that can actually be transmitted based on the number of tokens.

    Tokens are always consumed in whole by each DDS.DataWriter. That is, in cases where DDS.FlowControllerTokenBucketProperty_t.bytes_per_token is greater than the sample size, multiple samples may be sent to the same destination using a single token (regardless of DDS.FlowControllerProperty_t.scheduling_policy).

    Where fragmentation is required, the fragment size will be DDS.FlowControllerTokenBucketProperty_t.bytes_per_token or the minimum largest message size across all transports installed with the DDS.DataWriter, whichever is less.

    Use DDS.LENGTH_UNLIMITED to indicate that an unlimited number of bytes can be transmitted per token. In other words, a single token allows the recipient DDS.DataWriter to transmit all its queued samples to a single destination. A separate token is required to send to each additional destination.

    [default] DDS.LENGTH_UNLIMITED

    [range] [1024,DDS.LENGTH_UNLIMITED]

    FlowControllerProperty_T

    type FlowControllerProperty_T is record
          Scheduling_Policy  : aliased DDS.FlowControllerSchedulingPolicy := EDF_FLOW_CONTROLLER_SCHED_POLICY;
          Token_Bucket       : aliased DDS.FlowControllerTokenBucketProperty_T := (-1, -1, 0, (1, 0), -1);
          Is_Vendor_Specific : aliased DDS.Boolean := False;
       end record;

    Summary: Determines the flow control characteristics of the DDS.FlowController.

    The flow control characteristics shape the network traffic by determining how often and in what order associated asynchronous DDS.DataWriter instances are serviced and how much data they are allowed to send.

    Note that these settings apply directly to the DDS.FlowController, and do not depend on the number of DDS.DataWriter instances the DDS.FlowController is servicing. For instance, the specified flow rate does not double simply because two DDS.DataWriter instances are waiting to write.

    Entity:
    DDS.FlowController

    Properties:
    "Rx0" = N/A

    "Changeable" = "NO" for DDS.FlowControllerProperty_t.scheduling_policy, "YES" for DDS.FlowControllerProperty_t.token_bucket. However, the special value of DDS_DURATION_INFINITE as DDS.FlowControllerTokenBucketProperty_t.period is strictly used to create an on-demand DDS.FlowController. The token period cannot toggle from an infinite to finite value (or vice versa). It can, however, change from one finite value to another.

    The flow control characteristics shape the network traffic by determining how often and in what order associated asynchronous DDS.DataWriter instances are serviced and how much data they are allowed to send.

    Note that these settings apply directly to the DDS.FlowController, and do not depend on the number of DDS.DataWriter instances the DDS.FlowController is servicing. For instance, the specified flow rate does not double simply because two DDS.DataWriter instances are waiting to write.

    Entity:
    DDS.FlowController

    Properties:
    "Rx0" = N/A

    "Changeable" = "NO" for DDS.FlowControllerProperty_t.scheduling_policy, "YES" for DDS.FlowControllerProperty_t.token_bucket. However, the special value of DDS_DURATION_INFINITE as DDS.FlowControllerTokenBucketProperty_t.period is strictly used to create an on-demand DDS.FlowController. The token period cannot toggle from an infinite to finite value (or vice versa). It can, however, change from one finite value to another.

    scheduling_policy: Scheduling policy.

    Determines the scheduling policy for servicing the DDS.DataWriter instances associated with the DDS.FlowController.

    [default] DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    token_bucket: Settings for the token bucket.

    ReferenceScope

    type ReferenceScope is
         (SIMPLE_CONTENT_SCOPE,
          REFERENCED_CONTENTS_SCOPE);

    ObjectScope

    type ObjectScope is
         (SIMPLE_OBJECT_SCOPE,
          CONTAINED_OBJECTS_SCOPE,
          RELATED_OBJECTS_SCOPE);

    DCPSState

    type DCPSState is
         (INITIAL,
          REGISTERED,
          ENABLED);

    CacheUsage

    type CacheUsage is
         (READ_ONLY,
          WRITE_ONLY,
          READ_WRITE);

    ObjectSubState

    type ObjectSubState is new Interfaces.Unsigned_16;

    DLRLOid

    type DLRLOid is record
          Creator_Id : aliased Unsigned_Long;
          Local_Id   : aliased Unsigned_Long;
       end record;

    TimeOutDuration

    type TimeOutDuration is    new Interfaces.Unsigned_32;

    ClassName

    subtype ClassName is DDS.String;

    CacheName

    subtype CacheName is  DDS.String;

    RelationName

    subtype RelationName is DDS.String;

    ObjectReference

    type ObjectReference is record
          Oid        : DLRLOid;
          Home_Index : Unsigned_Long;
       end record;

    RelationKind

    type RelationKind is
         (REF_RELATION,
          LIST_RELATION,
          INT_MAP_RELATION,
          STR_MAP_RELATION);

    RelatedObjectDepth

    type RelatedObjectDepth is   new Short_Integer;

    MembershipState

    type MembershipState is
         (UNDEFINED_MEMBERSHIP,
          ALREADY_MEMBER,
          NOT_MEMBER);

    Constants & Global variables

    Binding_Version

    Binding_Version : constant Standard.String := "5.10";

    Null_Octets

    Null_Octets : constant Octets := (0, System.Null_Address);

    NULL_STRING

    NULL_STRING     : constant DDS.String := (Data => Interfaces.C.Strings.Null_Ptr);

    DOMAIN_ID_MAX

    DOMAIN_ID_MAX : constant := 250;

    Default_Domain

    Default_Domain  : constant DomainId_T := 0;

    Time_Zero

    Time_Zero       : constant Time_T := (0, 0);

    Summary: The default instant in time: zero seconds and zero nanoseconds

    TIME_INVALID_SEC

    TIME_INVALID_SEC : constant Long      := -1;

    Summary: A sentinel indicating an invalid second of time

    TIME_INVALID_NSEC

    TIME_INVALID_NSEC : constant Unsigned_Long      := 4_294_967_295;

    Summary: A sentinel indicating an invalid nano-second of time

    Time_Invalid

    Time_Invalid    : constant Time_T := (TIME_INVALID_SEC, TIME_INVALID_NSEC);

    Summary: A sentinel indicating an invalid time

    DURATION_ZERO_SEC

    DURATION_ZERO_SEC : constant Long := 0;

    Summary: A zero-length second period of time.

    DURATION_ZERO_NSEC

    DURATION_ZERO_NSEC : constant Unsigned_Long := 0;

    Summary: A zero-length nano-second period of time.

    DURATION_ZERO

    Summary: A zero-length period of time.

    DURATION_INFINITE_SEC

    DURATION_INFINITE_SEC : constant Long := 2_147_483_647;

    Summary: An infinite second period of time.

    DURATION_INFINITE_NSEC

    DURATION_INFINITE_NSEC : constant Unsigned_Long := 2_1474_83_647;

    Summary: An infinite nano-second period of time.

    DURATION_INFINITE

    DURATION_INFINITE : constant Duration_T :=
                             (DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC);

    Summary: An infinite period of time.

    DURATION_AUTO_SEC

    DURATION_AUTO_SEC : constant Long := 2_1474_83_647;

    Summary: An auto second period of time.

    DURATION_AUTO_NSEC

    DURATION_AUTO_NSEC : constant Unsigned_Long := 0;

    Summary: An auto nano-second period of time.

    DURATION_AUTO

    DURATION_AUTO     : constant Duration_T :=
                             (DURATION_AUTO_SEC, DURATION_AUTO_NSEC);

    Summary: Duration is automatically assigned.

    Null_InstanceHandle_T

    Null_InstanceHandle_T : aliased constant InstanceHandle_T := InstanceHandle_T (RTIDDS.Low_Level.dds_c.infrastructure_h.DDS_HANDLE_NIL);

    HANDLE_NIL

    HANDLE_NIL      : aliased constant InstanceHandle_T := Null_InstanceHandle_T;

    Summary: The NIL instance handle.

    Special DDS.InstanceHandle_t value


    See also: DDS_InstanceHandle_is_nil

    GUID_AUTO

    GUID_AUTO : aliased constant Guid_T := (Value => (others => 0));

    Summary: Indicates that RTI Connext should choose an appropriate virtual GUID.

    If this special value is assigned to DDS.DataWriterProtocolQosPolicy.virtual_guid or DDS.DataReaderProtocolQosPolicy.virtual_guid, RTI Connext will assign the virtual GUID automatically based on the RTPS or physical GUID.

    GUID_UNKNOWN

    GUID_UNKNOWN : Guid_T renames GUID_AUTO;

    Summary: Unknown GUID.

    SEQUENCE_NUMBER_UNKNOWN

    SEQUENCE_NUMBER_UNKNOWN : constant  SequenceNumber_T := (High => -1, Low =>  4294967295);

    Summary: Unknown sequence number.

    SEQUENCE_NUMBER_ZERO

    SEQUENCE_NUMBER_ZERO    : constant  SequenceNumber_T := (High =>  0, Low =>  0);

    Summary: Zero value for the sequence number.

    SEQUENCE_NUMBER_MAX

    SEQUENCE_NUMBER_MAX     : constant  SequenceNumber_T := (High =>  2147483647, Low =>  4294967295);

    Summary: Highest, most positive value for the sequence number.

    AUTO_SEQUENCE_NUMBER

    AUTO_SEQUENCE_NUMBER    : constant SequenceNumber_T := (High => -1, Low =>  4294967295);

    Summary: The sequence number is internally determined by dds

    ERROR

    ERROR                : exception;

    Summary: Superclass of all exceptions thrown by the RTI Connext API.

    Applications are not expected to throw or extend this type, but to handle exceptions of its more-specific subclasses.

    Summary: Generic, unspecified error.

    UNSUPPORTED

    UNSUPPORTED          : exception;

    Summary: Unsupported operation. Can only returned by operations that are unsupported.

    BAD_PARAMETER

    BAD_PARAMETER        : exception;

    Summary: Illegal parameter value.

    The value of the parameter that is passed in has llegal value. Things that fall into this category include ull_value parameters and parameter values that are out of range.

    PRECONDITION_NOT_MET

    PRECONDITION_NOT_MET : exception;

    Summary: A pre-condition for the operation was not met.

    The system is not in the expected state when the function is called, or the parameter itself is not in the expected state when the function is called.

    OUT_OF_RESOURCES

    OUT_OF_RESOURCES     : exception;

    Summary: RTI Connext ran out of the resources needed to complete the operation.

    NOT_ENABLED

    NOT_ENABLED          : exception;

    Summary: Operation invoked on a DDS.Entity that is not yet enabled.

    IMMUTABLE_POLICY

    IMMUTABLE_POLICY     : exception;

    Summary: Application attempted to modify an immutable QoS policy.

    INCONSISTENT_POLICY

    INCONSISTENT_POLICY  : exception;

    Summary: Application specified a set of QoS policies that are not consistent with each other.

    ALREADY_DELETED

    ALREADY_DELETED      : exception;

    Summary: The object target of this operation has already been deleted.

    TIMEOUT

    TIMEOUT              : exception;

    Summary: The operation timed out.

    NO_DATA

    NO_DATA              : exception;

    Summary: Indicates a transient situation where the operation did not return any data but there is no inherent error.

    ILLEGAL_OPERATION

    ILLEGAL_OPERATION    : exception;

    Summary: The operation was called under improper circumstances.

    An operation was invoked on an inappropriate object or at an inappropriate time. This return code is similar to DDS.RETCODE_PRECONDITION_NOT_MET, except that there is no precondition that could be changed to make the operation succeed.

    INCONSISTENT_TOPIC_STATUS

    INCONSISTENT_TOPIC_STATUS         : constant StatusKind := 2#0000_0000_0000_0001#;

    Summary: Another topic exists with the same name but different characteristics.

    Entity:
    DDS.Topic

    Status:
    DDS.InconsistentTopicStatus

    Listener:
    DDS.TopicListener

    OFFERED_DEADLINE_MISSED_STATUS

    OFFERED_DEADLINE_MISSED_STATUS    : constant StatusKind := 2#0000_0000_0000_0010#;

    Summary: The deadline that the DDS.DataWriter has committed through its DDS.DeadlineQosPolicy was not respected for a specific instance.

    Entity:
    DDS.DataWriter

    QoS:
    DDSDeadlineQosModule

    Status:
    DDS.OfferedDeadlineMissedStatus

    Listener:
    DDS.DataWriterListener

    REQUESTED_DEADLINE_MISSED_STATUS

    REQUESTED_DEADLINE_MISSED_STATUS  : constant StatusKind := 2#0000_0000_0000_0100#;

    Summary: The deadline that the DDS.DataReader was expecting through its DDS.DeadlineQosPolicy was not respected for a specific instance.

    Entity:
    DDS.DataReader

    QoS:
    DDSDeadlineQosModule

    Status:
    DDS.RequestedDeadlineMissedStatus

    Listener:
    DDS.DataReaderListener

    OFFERED_INCOMPATIBLE_QOS_STATUS

    OFFERED_INCOMPATIBLE_QOS_STATUS   : constant StatusKind := 2#0000_0000_0010_0000#;

    Summary: A QosPolicy value was incompatible with what was requested.

    Entity:
    DDS.DataWriter

    Status:
    DDS.OfferedIncompatibleQosStatus

    Listener:
    DDS.DataWriterListener

    REQUESTED_INCOMPATIBLE_QOS_STATUS

    REQUESTED_INCOMPATIBLE_QOS_STATUS : constant StatusKind := 2#0000_0000_0100_0000#;

    Summary: A QosPolicy value was incompatible with what is offered.

    Entity:
    DDS.DataReader

    Status:
    DDS.RequestedIncompatibleQosStatus

    Listener:
    DDS.DataReaderListener

    SAMPLE_LOST_STATUS

    SAMPLE_LOST_STATUS                : constant StatusKind := 2#0000_0000_1000_0000#;

    Summary: A sample has been lost (i.e. was never received).

    Entity:
    DDS.DataReader

    Status:
    DDS.SampleLostStatus

    Listener:
    DDS.DataReaderListener

    SAMPLE_REJECTED_STATUS

    SAMPLE_REJECTED_STATUS            : constant StatusKind := 2#0000_0001_0000_0000#;

    Summary: A (received) sample has been rejected.

    Entity:
    DDS.DataReader

    QoS:
    DDSResourceLimitsQosModule

    Status:
    DDS.SampleRejectedStatus

    Listener:
    DDS.DataReaderListener

    DATA_ON_READERS_STATUS

    DATA_ON_READERS_STATUS            : constant StatusKind := 2#0000_0010_0000_0000#;

    Summary: New data is available.

    Entity:
    DDS.Subscriber

    Listener:
    DDS.SubscriberListener

    DATA_AVAILABLE_STATUS

    DATA_AVAILABLE_STATUS             : constant StatusKind := 2#0000_0100_0000_0000#;

    Summary: One or more new data samples have been received.

    Entity:
    DDS.DataReader

    Listener:
    DDS.DataReaderListener

    LIVELINESS_LOST_STATUS

    LIVELINESS_LOST_STATUS            : constant StatusKind := 2#0000_1000_0000_0000#;

    Summary: The liveliness that the DDS.DataWriter has committed to through its DDS.LivelinessQosPolicy was not respected, thus DDS.DataReader entities will consider the DDS.DataWriter as no longer alive.

    Entity:
    DDS.DataWriter

    QoS:
    DDSLivelinessQosModule

    Status:
    DDS.LivelinessLostStatus

    Listener:
    DDS.DataWriterListener

    LIVELINESS_CHANGED_STATUS

    LIVELINESS_CHANGED_STATUS         : constant StatusKind := 2#0001_0000_0000_0000#;

    Summary: The liveliness of one or more DDS.DataWriter that were writing instances read through the DDS.DataReader has changed. Some DDS.DataWriter have become alive or not_alive.

    Entity:
    DDS.DataReader

    QoS:
    DDSLivelinessQosModule

    Status:
    DDS.LivelinessChangedStatus

    Listener:
    DDS.DataReaderListener

    PUBLICATION_MATCH_STATUS

    PUBLICATION_MATCH_STATUS          : constant StatusKind := 2#0010_0000_0000_0000#;

    Summary: The DDS.DataWriter has found DDS.DataReader that matches the DDS.Topic and has compatible QoS.

    Entity:
    DDS.DataWriter

    Status:
    DDS.PublicationMatchedStatus

    Listener:
    DDS.DataWriterListener

    SUBSCRIPTION_MATCH_STATUS

    SUBSCRIPTION_MATCH_STATUS         : constant StatusKind := 2#0100_0000_0000_0000#;

    Summary: The DDS.DataReader has found DDS.DataWriter that matches the DDS.Topic and has compatible QoS.

    Entity:
    DDS.DataReader

    Status:
    DDS.SubscriptionMatchedStatus

    Listener:
    DDS.DataReaderListener

    DATA_WRITER_APPLICATION_ACKNOWLEDGMENT_STATUS

    DATA_WRITER_APPLICATION_ACKNOWLEDGMENT_STATUS : constant StatusKind :=
                                                         2#0000_0000_0100_0000_0000_0000_0000_0000#;

    Summary: <<ext>> A DDS.DataWriter has received an application-level acknowledgment for a sample

    Enables a DDS.DataWriter callback that is called when an application-level acknowledgment from a DDS.DataReader is received. The callback is called for each sample that is application-level acknowledged. Changes to this status do not trigger a DDS.StatusCondition.

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    DATA_WRITER_INSTANCE_REPLACED_STATUS

    DATA_WRITER_INSTANCE_REPLACED_STATUS       : constant StatusKind :=
                                                      2#0000_0000_1000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> A DDS.DataWriter instance has been replaced

    Enables a DDS.DataWriter callback that is called when an instance in the writer queue is replaced.

    Entity:
    DDS.DataWriter

    Listener:
    DDS.DataWriterListener

    RELIABLE_WRITER_CACHE_CHANGED_STATUS

    RELIABLE_WRITER_CACHE_CHANGED_STATUS       : constant StatusKind :=
                                                      2#0000_0001_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> The number of unacknowledged samples in a reliable writer's cache has changed such that it has reached a pre-defined trigger point.

    This status is considered changed at the following times: the cache is empty (i.e. contains no unacknowledge samples), full (i.e. the sample count has reached the value specified in DDS.ResourceLimitsQosPolicy.max_samples), or the number of samples has reached a high (see DDS.RtpsReliableWriterProtocol_t.high_watermark) or low (see DDS.RtpsReliableWriterProtocol_t.low_watermark) watermark.

    Entity:
    DDS.DataWriter

    Status:
    DDS.ReliableWriterCacheChangedStatus

    Listener:
    DDS.DataWriterListener

    RELIABLE_READER_ACTIVITY_CHANGED_STATUS

    RELIABLE_READER_ACTIVITY_CHANGED_STATUS    : constant StatusKind :=
                                                      2#0000_0010_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> One or more reliable readers has become active or inactive.

    A reliable reader is considered active by a reliable writer with which it is matched if that reader acknowledges the samples it has been sent in a timely fashion. For the definition of "timely" in this case, see DDS.RtpsReliableWriterProtocol_t and DDS.ReliableReaderActivityChangedStatus.


    See also: DDS.RtpsReliableWriterProtocol_t
    See also: DDS.ReliableReaderActivityChangedStatus

    DATA_WRITER_CACHE_STATUS

    DATA_WRITER_CACHE_STATUS                   : constant StatusKind :=
                                                      2#0000_0100_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> The status of the writer's cache.

    Changes to this status do not trigger a DDS.StatusCondition.

    DATA_WRITER_PROTOCOL_STATUS

    DATA_WRITER_PROTOCOL_STATUS                : constant StatusKind :=
                                                      2#0000_1000_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> The status of a writer's internal protocol related metrics

    The status of a writer's internal protocol related metrics, like the number of samples pushed, pulled, filtered; and status of wire protocol traffic. Changes to this status do not trigger a DDS.StatusCondition.

    DATA_READER_CACHE_STATUS

    DATA_READER_CACHE_STATUS                   : constant StatusKind :=
                                                      2#0001_0000_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> The status of the reader's cache.

    Changes to this status do not trigger a DDS.StatusCondition.

    DATA_READER_PROTOCOL_STATUS

    DATA_READER_PROTOCOL_STATUS                : constant StatusKind :=
                                                      2#0010_0000_0000_0000_0000_0000_0000_0000#;

    Summary: <<ext>> The status of a reader's internal protocol related metrics

    The status of a reader's internal protocol related metrics, like the number of samples received, filtered, rejected; and status of wire protocol traffic. Changes to this status do not trigger a DDS.StatusCondition.

    DATA_WRITER_DESTINATION_UNREACHABLE_STATUS

    DATA_WRITER_DESTINATION_UNREACHABLE_STATUS : constant StatusKind :=
                                                      2#0100_0000_0000_0000_0000_0000_0000_0000#;

    DATA_WRITER_SAMPLE_REMOVED_STATUS

    DATA_WRITER_SAMPLE_REMOVED_STATUS          : constant StatusKind :=
                                                      2#1000_0000_0000_0000_0000_0000_0000_0000#;

    STATUS_MASK_NONE

    STATUS_MASK_NONE : constant StatusMask := 2#0000_0000_0000_0000_0000_0000_0000_0000#;

    Summary: No bits are set.

    STATUS_MASK_ALL

    STATUS_MASK_ALL  : constant StatusMask := 2#1111_1111_1000_0000_0111_1111_1110_0111#;

    Summary: All bits are set.

    THREAD_SETTINGS_OPTION_DEFAULT

    THREAD_SETTINGS_OPTION_DEFAULT             : constant := 16#00#;

    THREAD_SETTINGS_OPTION_FLOATING_POINT

    THREAD_SETTINGS_OPTION_FLOATING_POINT      : constant := 16#01#;

    Summary: A collection of flags used to configure threads of execution.

    Not all of these options may be relevant for all operating systems. Consult Platform Notes for additional details.
    See also: DDS.ThreadSettingsKindMask

    Summary: Code executed within the thread may perform floating point operations.

    Currently applicable only for VxWorks platforms, where user callbacks use floating-point operations.

    THREAD_SETTINGS_OPTION_STDIO

    THREAD_SETTINGS_OPTION_STDIO               : constant := 16#02#;

    Summary: Code executed within the thread may access standard I/O.

    Currently applicable only for VxWorks platforms, where user callbacks do standard I/O operations.

    THREAD_SETTINGS_OPTION_REALTIME_PRIORITY

    THREAD_SETTINGS_OPTION_REALTIME_PRIORITY   : constant := 16#08#;

    THREAD_SETTINGS_OPTION_PRIORITY_ENFORCE

    THREAD_SETTINGS_OPTION_PRIORITY_ENFORCE    : constant := 16#10#;

    Summary: Strictly enforce this thread's priority.

    THREAD_SETTINGS_OPTION_CANCEL_ASYNCHRONOUS

    THREAD_SETTINGS_OPTION_CANCEL_ASYNCHRONOUS : constant := 16#20#;

    Summary: Allows the thread to be cancelled without first reaching a cancellable state or cancellation point.

    THREAD_SETTINGS_KIND_MASK_DEFAULT

    THREAD_SETTINGS_KIND_MASK_DEFAULT          : constant ThreadSettingsKindMask :=
                                                      THREAD_SETTINGS_OPTION_DEFAULT;

    Summary: The mask of default thread options.

    THREAD_SETTINGS_CPU_NO_ROTATION

    THREAD_SETTINGS_CPU_NO_ROTATION            : constant ThreadSettingsCpuRotationKind_T := 0;

    Summary: Any thread controlled by this QoS can run on any listed processor, as determined by OS scheduling.

    THREAD_SETTINGS_CPU_RR_ROTATION

    THREAD_SETTINGS_CPU_RR_ROTATION            : constant ThreadSettingsCpuRotationKind_T := 1;

    Summary: Threads controlled by this QoS will be assigned one processor from the list in round-robin order.

    THREAD_SETTINGS_CPU_ROTATION_DEFAULT

    THREAD_SETTINGS_CPU_ROTATION_DEFAULT       : constant ThreadSettingsCpuRotationKind_T :=
                                                      THREAD_SETTINGS_CPU_NO_ROTATION;

    QOS_POLICY_COUNT

    QOS_POLICY_COUNT : constant Long := 59;

    Summary: Number of QoS policies in DDS.QosPolicyId_t.

    INVALID_QOS_POLICY_ID

    INVALID_QOS_POLICY_ID : constant QosPolicyId_T := 0;

    Summary: Identifier for an invalid QoS policy

    USERDATA_QOS_POLICY_ID

    USERDATA_QOS_POLICY_ID : constant QosPolicyId_T := 1;

    Summary: Identifier for DDS.UserDataQosPolicy

    DURABILITY_QOS_POLICY_ID

    DURABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 2;

    Summary: Identifier for DDS.DurabilityQosPolicy

    PRESENTATION_QOS_POLICY_ID

    PRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 3;

    Summary: Identifier for DDS.PresentationQosPolicy

    DEADLINE_QOS_POLICY_ID

    DEADLINE_QOS_POLICY_ID : constant QosPolicyId_T := 4;

    Summary: Identifier for DDS.DeadlineQosPolicy

    LATENCYBUDGET_QOS_POLICY_ID

    LATENCYBUDGET_QOS_POLICY_ID : constant QosPolicyId_T := 5;

    Summary: Identifier for DDS.LatencyBudgetQosPolicy

    OWNERSHIP_QOS_POLICY_ID

    OWNERSHIP_QOS_POLICY_ID : constant QosPolicyId_T := 6;

    Summary: Identifier for DDS.OwnershipQosPolicy

    OWNERSHIPSTRENGTH_QOS_POLICY_ID

    OWNERSHIPSTRENGTH_QOS_POLICY_ID : constant QosPolicyId_T := 7;

    Summary: Identifier for DDS.OwnershipStrengthQosPolicy

    LIVELINESS_QOS_POLICY_ID

    LIVELINESS_QOS_POLICY_ID : constant QosPolicyId_T := 8;

    Summary: Identifier for DDS.LivelinessQosPolicy

    TIMEBASEDFILTER_QOS_POLICY_ID

    TIMEBASEDFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 9;

    Summary: Identifier for DDS.TimeBasedFilterQosPolicy

    PARTITION_QOS_POLICY_ID

    PARTITION_QOS_POLICY_ID : constant QosPolicyId_T := 10;

    Summary: Identifier for DDS.PartitionQosPolicy

    RELIABILITY_QOS_POLICY_ID

    RELIABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 11;

    Summary: Identifier for DDS.ReliabilityQosPolicy

    DESTINATIONORDER_QOS_POLICY_ID

    DESTINATIONORDER_QOS_POLICY_ID : constant QosPolicyId_T := 12;

    Summary: Identifier for DDS.DestinationOrderQosPolicy

    HISTORY_QOS_POLICY_ID

    HISTORY_QOS_POLICY_ID : constant QosPolicyId_T := 13;

    Summary: Identifier for DDS.HistoryQosPolicy

    RESOURCELIMITS_QOS_POLICY_ID

    RESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 14;

    Summary: Identifier for DDS.ResourceLimitsQosPolicy

    ENTITYFACTORY_QOS_POLICY_ID

    ENTITYFACTORY_QOS_POLICY_ID : constant QosPolicyId_T := 15;

    Summary: Identifier for DDS.EntityFactoryQosPolicy

    WRITERDATALIFECYCLE_QOS_POLICY_ID

    WRITERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 16;

    Summary: Identifier for DDS.WriterDataLifecycleQosPolicy

    READERDATALIFECYCLE_QOS_POLICY_ID

    READERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 17;

    Summary: Identifier for DDS.ReaderDataLifecycleQosPolicy

    TOPICDATA_QOS_POLICY_ID

    TOPICDATA_QOS_POLICY_ID : constant QosPolicyId_T := 18;

    Summary: Identifier for DDS.TopicDataQosPolicy

    GROUPDATA_QOS_POLICY_ID

    GROUPDATA_QOS_POLICY_ID : constant QosPolicyId_T := 19;

    Summary: Identifier for DDS.GroupDataQosPolicy

    TRANSPORTPRIORITY_QOS_POLICY_ID

    TRANSPORTPRIORITY_QOS_POLICY_ID : constant QosPolicyId_T := 20;

    Summary: Identifier for DDS.TransportPriorityQosPolicy

    LIFESPAN_QOS_POLICY_ID

    LIFESPAN_QOS_POLICY_ID : constant QosPolicyId_T := 21;

    Summary: Identifier for DDS.LifespanQosPolicy

    DURABILITYSERVICE_QOS_POLICY_ID

    DURABILITYSERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 22;

    Summary: Identifier for DDS.DurabilityServiceQosPolicy

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID : constant QosPolicyId_T := 24;

    WIREPROTOCOL_QOS_POLICY_ID

    WIREPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1000;

    Summary: <<ext>> Identifier for DDS.WireProtocolQosPolicy

    DISCOVERY_QOS_POLICY_ID

    DISCOVERY_QOS_POLICY_ID : constant QosPolicyId_T := 1001;

    Summary: <<ext>> Identifier for DDS.DiscoveryQosPolicy

    DATAREADERRESOURCELIMITS_QOS_POLICY_ID

    DATAREADERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1003;

    Summary: <<ext>> Identifier for DDS.DataReaderResourceLimitsQosPolicy

    DATAWRITERRESOURCELIMITS_QOS_POLICY_ID

    DATAWRITERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1004;

    Summary: <<ext>> Identifier for DDS.DataWriterResourceLimitsQosPolicy

    DATAREADERPROTOCOL_QOS_POLICY_ID

    DATAREADERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1005;

    Summary: <<ext>> Identifier for DDS.DataReaderProtocolQosPolicy

    DATAWRITERPROTOCOL_QOS_POLICY_ID

    DATAWRITERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1006;

    Summary: <<ext>> Identifier for DDS.DataWriterProtocolQosPolicy

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1007;

    Summary: <<ext>> Identifier for DDS.DomainParticipantResourceLimitsQosPolicy

    EVENT_QOS_POLICY_ID

    EVENT_QOS_POLICY_ID : constant QosPolicyId_T := 1008;

    Summary: <<ext>> Identifier for DDS.EventQosPolicy

    DATABASE_QOS_POLICY_ID

    DATABASE_QOS_POLICY_ID : constant QosPolicyId_T := 1009;

    Summary: <<ext>> Identifier for DDS.DatabaseQosPolicy

    RECEIVERPOOL_QOS_POLICY_ID

    RECEIVERPOOL_QOS_POLICY_ID : constant QosPolicyId_T := 1010;

    Summary: <<ext>> Identifier for DDS.ReceiverPoolQosPolicy

    DISCOVERYCONFIG_QOS_POLICY_ID

    DISCOVERYCONFIG_QOS_POLICY_ID : constant QosPolicyId_T := 1011;

    Summary: <<ext>> Identifier for DDS.DiscoveryConfigQosPolicy

    EXCLUSIVEAREA_QOS_POLICY_ID

    EXCLUSIVEAREA_QOS_POLICY_ID : constant QosPolicyId_T := 1012;

    Summary: <<ext>> Identifier for DDS.ExclusiveAreaQosPolicy

    USEROBJECT_QOS_POLICY_ID

    USEROBJECT_QOS_POLICY_ID : constant QosPolicyId_T := 1013;

    SYSTEMRESOURCELIMITS_QOS_POLICY_ID

    SYSTEMRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1014;

    Summary: <<ext>> Identifier for DDS.SystemResourceLimitsQosPolicy

    TRANSPORTSELECTION_QOS_POLICY_ID

    TRANSPORTSELECTION_QOS_POLICY_ID : constant QosPolicyId_T := 1015;

    Summary: <<ext>> Identifier for DDS.TransportSelectionQosPolicy

    TRANSPORTUNICAST_QOS_POLICY_ID

    TRANSPORTUNICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1016;

    Summary: <<ext>> Identifier for DDS.TransportUnicastQosPolicy

    TRANSPORTMULTICAST_QOS_POLICY_ID

    TRANSPORTMULTICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1017;

    Summary: <<ext>> Identifier for DDS.TransportMulticastQosPolicy

    TRANSPORTBUILTIN_QOS_POLICY_ID

    TRANSPORTBUILTIN_QOS_POLICY_ID : constant QosPolicyId_T := 1018;

    Summary: <<ext>> Identifier for DDS.TransportBuiltinQosPolicy

    TYPESUPPORT_QOS_POLICY_ID

    TYPESUPPORT_QOS_POLICY_ID : constant QosPolicyId_T := 1019;

    Summary: <<ext>> Identifier for DDS.TypeSupportQosPolicy

    PROPERTY_QOS_POLICY_ID

    PROPERTY_QOS_POLICY_ID : constant QosPolicyId_T := 1020;

    Summary: <<ext>> Identifier for DDS.PropertyQosPolicy

    PUBLISHMODE_QOS_POLICY_ID

    PUBLISHMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1021;

    Summary: <<ext>> Identifier for DDS.PublishModeQosPolicy

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID : constant QosPolicyId_T := 1022;

    Summary: <<ext>> Identifier for DDS.AsynchronousPublisherQosPolicy

    ENTITYNAME_QOS_POLICY_ID

    ENTITYNAME_QOS_POLICY_ID : constant QosPolicyId_T := 1023;

    Summary: <<ext>> Identifier for DDS.EntityNameQosPolicy

    SERVICE_QOS_POLICY_ID

    SERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 1025;

    BATCH_QOS_POLICY_ID

    BATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1026;

    Summary: <<ext>> Identifier for DDS.BatchQosPolicy

    PROFILE_QOS_POLICY_ID

    PROFILE_QOS_POLICY_ID : constant QosPolicyId_T := 1027;

    Summary: <<ext>> Identifier for DDS.ProfileQosPolicy

    LOCATORFILTER_QOS_POLICY_ID

    LOCATORFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 1028;

    Summary: <<ext>> Identifier for DDS.LocatorFilterQosPolicy

    MULTICHANNEL_QOS_POLICY_ID

    MULTICHANNEL_QOS_POLICY_ID : constant QosPolicyId_T := 1029;

    Summary: <<ext>> Identifier for DDS.MultiChannelQosPolicy

    TRANSPORTENCAPSULATION_QOS_POLICY_ID

    TRANSPORTENCAPSULATION_QOS_POLICY_ID : constant QosPolicyId_T := 1030;

    PUBLISHERPROTOCOL_QOS_POLICY_ID

    PUBLISHERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1031;

    SUBSCRIBERPROTOCOL_QOS_POLICY_ID

    SUBSCRIBERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1032;

    TOPICPROTOCOL_QOS_POLICY_ID

    TOPICPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1033;

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1034;

    AVAILABILITY_QOS_POLICY_ID

    AVAILABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 1035;

    Summary: <<ext>> Identifier for DDS.AvailabilityQosPolicy

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID : constant QosPolicyId_T := 1036;
    QosPolicyId_t_TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID -- documentation removed in ifdoc

    LOGGING_QOS_POLICY_ID

    LOGGING_QOS_POLICY_ID : constant QosPolicyId_T := 1037;

    Summary: <<ext>> Identifier for DDS.LoggingQosPolicy

    USERDATA_QOS_POLICY_NAME

    USERDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserData");

    Summary: Stringified human-readable name for DDS.UserDataQosPolicy

    TOPICDATA_QOS_POLICY_NAME

    TOPICDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicData");

    Summary: Stringified human-readable name for DDS.TopicDataQosPolicy

    GROUPDATA_QOS_POLICY_NAME

    GROUPDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("GroupData");

    Summary: Stringified human-readable name for DDS.GroupDataQosPolicy

    TOPICPROTOCOL_QOS_POLICY_NAME

    TOPICPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicProtocol");

    TOPIC_PROTOCOL_QOS_POLICY_DEFAULT

    TOPIC_PROTOCOL_QOS_POLICY_DEFAULT : constant TopicProtocolQosPolicy :=
                                             (Vendor_Specific_Entity => False);

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantProtocol");

    DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT

    DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT : constant DomainParticipantProtocolQosPolicy :=
                                                          (Vendor_Specific_Entity => False);

    DURABILITY_QOS_POLICY_NAME

    DURABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Durability");

    Summary: Stringified human-readable name for DDS.DurabilityQosPolicy

    VOLATILE_DURABILITY_QOS

    VOLATILE_DURABILITY_QOS : constant DurabilityQosPolicyKind := 0;

    Summary: [default] RTI Connext does not need to keep any samples of data instances on behalf of any DDS.DataReader that is unknown by the DDS.DataWriter at the time the instance is written.

    In other words, RTI Connext will only attempt to provide the data to existing subscribers.

    This option does not require RTI Persistence Service.

    TRANSIENT_LOCAL_DURABILITY_QOS

    TRANSIENT_LOCAL_DURABILITY_QOS : constant DurabilityQosPolicyKind := 1;

    Summary: RTI Connext will attempt to keep some samples so that they can be delivered to any potential late-joining DDS.DataReader.

    Which particular samples are kept depends on other QoS such as DDS.HistoryQosPolicy and DDS.ResourceLimitsQosPolicy. RTI Connext is only required to keep the data in memory of the DDS.DataWriter that wrote the data.

    Data is not required to survive the DDS.DataWriter.

    For this setting to be effective, you must also set the DDS.ReliabilityQosPolicy.kind to DDS.RELIABLE_RELIABILITY_QOS.

    This option does not require RTI Persistence Service.

    TRANSIENT_DURABILITY_QOS

    TRANSIENT_DURABILITY_QOS : constant DurabilityQosPolicyKind := 2;

    Summary: RTI Connext will attempt to keep some samples so that they can be delivered to any potential late-joining DDS.DataReader.

    Which particular samples are kept depends on other QoS such as DDS.HistoryQosPolicy and DDS.ResourceLimitsQosPolicy. RTI Connext is only required to keep the data in memory and not in permanent storage.

    Data is not tied to the lifecycle of the DDS.DataWriter.

    Data will survive the DDS.DataWriter.

    This option requires RTI Persistence Service.

    PERSISTENT_DURABILITY_QOS

    PERSISTENT_DURABILITY_QOS : constant DurabilityQosPolicyKind := 3;

    Summary: Data is kept on permanent storage, so that they can outlive a system session.

    This option requires RTI Persistence Service.

    DURABILITY_QOS_POLICY_DEFAULT

    DURABILITY_QOS_POLICY_DEFAULT : constant DurabilityQosPolicy :=
                                         (Kind                 => VOLATILE_DURABILITY_QOS,
                                          Direct_Communication => True);

    PRESENTATION_QOS_POLICY_NAME

    PRESENTATION_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("Presentation");

    Summary: Stringified human-readable name for DDS.PresentationQosPolicy

    INSTANCE_PRESENTATION_QOS

    INSTANCE_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 0;

    Summary: [default] Scope spans only a single instance.

    Indicates that changes to one instance need not be coherent nor ordered with respect to changes to any other instance. In other words, order and coherent changes apply to each instance separately.

    TOPIC_PRESENTATION_QOS

    TOPIC_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 1;

    Summary: Scope spans to all instances within the same DDS.DataWriter (or DDS.DataReader), but not across instances in different DDS.DataWriter (or DDS.DataReader).

    GROUP_PRESENTATION_QOS

    GROUP_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 2;

    Summary: Scope spans to all instances belonging to DDS.DataWriter (or DDS.DataReader) entities within the same DDS.Publisher (or DDS.Subscriber).

    HIGHEST_OFFERED_PRESENTATION_QOS

    HIGHEST_OFFERED_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 3;

    Summary: This value only applies to a DDS.Subscriber. The DDS.Subscriber will use the access scope specified by each remote DDS.Publisher.

    PRESENTATION_QOS_POLICY_DEFAULT

    PRESENTATION_QOS_POLICY_DEFAULT : constant PresentationQosPolicy :=
                                           (INSTANCE_PRESENTATION_QOS,
                                            False,
                                            False);

    DEADLINE_QOS_POLICY_NAME

    DEADLINE_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("Deadline");

    Summary: Stringified human-readable name for DDS.DeadlineQosPolicy

    DEADLINE_QOS_POLICY_DEFAULT

    DEADLINE_QOS_POLICY_DEFAULT : constant DeadlineQosPolicy :=
                                       (Period => DURATION_INFINITE);

    LATENCYBUDGET_QOS_POLICY_NAME

    LATENCYBUDGET_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LatencyBudget");

    Summary: Stringified human-readable name for DDS.LatencyBudgetQosPolicy

    LATENCY_BUDGET_QOS_POLICY_DEFAULT

    LATENCY_BUDGET_QOS_POLICY_DEFAULT : constant LatencyBudgetQosPolicy :=
                                             (Duration => DURATION_ZERO);

    OWNERSHIP_QOS_POLICY_NAME

    OWNERSHIP_QOS_POLICY_NAME         : constant DDS.String := To_DDS_String ("Ownership");

    Summary: Stringified human-readable name for DDS.OwnershipQosPolicy

    SHARED_OWNERSHIP_QOS

    SHARED_OWNERSHIP_QOS : constant OwnershipQosPolicyKind := 0;

    Summary: [default] Indicates shared ownership for each instance.

    Multiple writers are allowed to update the same instance and all the updates are made available to the readers. In other words there is no concept of an owner for the instances.

    This is the default behavior if the DDSOwnershipQosModule policy is not specified or supported.

    EXCLUSIVE_OWNERSHIP_QOS

    EXCLUSIVE_OWNERSHIP_QOS : constant OwnershipQosPolicyKind := 1;

    Summary: Indicates each instance can only be owned by one DDS.DataWriter, but the owner of an instance can change dynamically.

    The selection of the owner is controlled by the setting of the DDSOwnershipStrengthQosModule policy. The owner is always set to be the highest-strength DDS.DataWriter object among the ones currently active (as determined by the DDSLivelinessQosModule).

    OWNERSHIP_QOS_POLICY_DEFAULT

    OWNERSHIP_QOS_POLICY_DEFAULT : constant OwnershipQosPolicy :=
                                        (Kind => SHARED_OWNERSHIP_QOS);

    OWNERSHIPSTRENGTH_QOS_POLICY_NAME

    OWNERSHIPSTRENGTH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("OwnershipStrength");

    Summary: Stringified human-readable name for DDS.OwnershipStrengthQosPolicy

    OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT

    OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT : constant OwnershipStrengthQosPolicy :=
                                                 (Value => 0);

    LIVELINESS_QOS_POLICY_NAME

    LIVELINESS_QOS_POLICY_NAME            : constant DDS.String := To_DDS_String ("Liveliness");

    Summary: Stringified human-readable name for DDS.LivelinessQosPolicy

    AUTOMATIC_LIVELINESS_QOS

    AUTOMATIC_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 0;

    Summary: [default] The infrastructure will automatically signal liveliness for the DDS.DataWriter (s) at least as often as required by the DDS.DataWriter (S) lease_duration.

    A DDS.DataWriter with this setting does not need to take any specific action in order to be considered 'alive.' The DDS.DataWriter is only 'not alive' when the participant to which it belongs terminates (gracefully or not), or when there is a network problem that prevents the current participant from contacting that remote participant.

    MANUAL_BY_PARTICIPANT_LIVELINESS_QOS

    MANUAL_BY_PARTICIPANT_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 1;

    Summary: RTI Connext will assume that as long as at least one DDS.DataWriter belonging to the DDS.DomainParticipant (or the DDS.DomainParticipant itself) has asserted its liveliness, then the other DataWriters belonging to that same DDS.DomainParticipant are also alive.

    The user application takes responsibility to signal liveliness to RTI Connext either by calling DDS.DomainParticipant.assert_liveliness, or by calling DDS.DataWriter.assert_liveliness, or FooDataWriter.write on any DDS.DataWriter belonging to the DDS.DomainParticipant.

    MANUAL_BY_TOPIC_LIVELINESS_QOS

    MANUAL_BY_TOPIC_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 2;

    Summary: RTI Connext will only assume liveliness of the DDS.DataWriter if the application has asserted liveliness of that DDS.DataWriter itself.

    The user application takes responsibility to signal liveliness to RTI Connext using the DDS.DataWriter.assert_liveliness procedure, or by writing some data.

    LIVELINESS_QOS_POLICY_DEFAULT

    LIVELINESS_QOS_POLICY_DEFAULT : constant LivelinessQosPolicy :=
                                         (Kind                          => AUTOMATIC_LIVELINESS_QOS,
                                          Lease_Duration                => DURATION_INFINITE,
                                          Assertions_Per_Lease_Duration => 3);

    TIMEBASEDFILTER_QOS_POLICY_NAME

    TIMEBASEDFILTER_QOS_POLICY_NAME : constant DDS.String  := To_DDS_String ("TimeBasedFilter");

    Summary: Stringified human-readable name for DDS.TimeBasedFilterQosPolicy

    TIME_BASED_FILTER_QOS_POLICY_DEFAULT

    TIME_BASED_FILTER_QOS_POLICY_DEFAULT : constant  TimeBasedFilterQosPolicy :=
                                                (Minimum_Separation => DURATION_ZERO);

    PARTITION_QOS_POLICY_NAME

    PARTITION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Partition");

    Summary: Stringified human-readable name for DDS.PartitionQosPolicy

    RELIABILITY_QOS_POLICY_NAME

    RELIABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Reliability");

    Summary: Stringified human-readable name for DDS.ReliabilityQosPolicy

    BEST_EFFORT_RELIABILITY_QOS

    BEST_EFFORT_RELIABILITY_QOS : constant ReliabilityQosPolicyKind := 0;

    Summary: Indicates that it is acceptable to not retry propagation of any samples.

    Presumably new values for the samples are generated often enough that it is not necessary to re-send or acknowledge any samples.

    [default] for DDS.DataReader and DDS.Topic

    RELIABLE_RELIABILITY_QOS

    RELIABLE_RELIABILITY_QOS : constant ReliabilityQosPolicyKind := 1;

    Summary: Specifies RTI Connext will attempt to deliver all samples in its history. Missed samples may be retried.

    In steady-state (no modifications communicated via the DDS.DataWriter), RTI Connext guarantees that all samples in the DDS.DataWriter history will eventually be delivered to all the DDS.DataReader objects (subject to timeouts that indicate loss of communication with a particular DDS.Subscriber).

    Outside steady state, the DDSHistoryQosModule and DDSResourceLimitsQosModule policies will determine how samples become part of the history and whether samples can be discarded from it.

    [default] for DDS.DataWriter

    PROTOCOL_ACKNOWLEDGMENT_MODE

    PROTOCOL_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 0;

    Summary: Samples are acknowledged by RTPS protocol

    Samples are acknowledged according to the Real-Time Publish-Subscribe (RTPS) interoperability protocol.

    APPICATION_AUTO_ACKNOWLEDGMENT_MODE

    APPICATION_AUTO_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 1;

    Summary: Samples are acknowleged automatically after a subscribing application has accessed them.

    A sample received by a FooDataReader is acknowledged after it has been taken and then returned. Specifically, all samples taken by a call to FooDataReader.take are acknowledged after FooDataReader.return_loan is called.

    APPICATION_ORDERED_ACKNOWLEDGMENT_MODE

    APPICATION_ORDERED_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 2;

    Summary: Samples up to a specified sequence number are acknowledged

    APPICATION_EXPLICIT_ACKNOWLEDGMENT_MODE

    APPICATION_EXPLICIT_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 3;

    Summary: Samples are acknowledged after the subscribing application explicitly calls acknowledge on the samples.

    Samples received by a DDS.DataReader are explicitly acknowledged by the subscribing application, after it calls either DDS.DataReader.acknowledge_all or DDS.DataReader.acknowledge_sample.

    RELIABILITY_QOS_POLICY_DEFAULT

    RELIABILITY_QOS_POLICY_DEFAULT : constant ReliabilityQosPolicy :=
                                          (BEST_EFFORT_RELIABILITY_QOS, (0, 100_000_000), PROTOCOL_ACKNOWLEDGMENT_MODE);

    DESTINATIONORDER_QOS_POLICY_NAME

    DESTINATIONORDER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DestinationOrder");

    Summary: Stringified human-readable name for DDS.DestinationOrderQosPolicy

    BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS

    BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyKind := 0;

    Summary: [default] Indicates that data is ordered based on the reception time at each DDS.Subscriber.

    Since each subscriber may receive the data at different times there is no guaranteed that the changes will be seen in the same order. Consequently, it is possible for each subscriber to end up with a different final value for the data.

    BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS

    BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyKind := 1;

    Summary: Indicates that data is ordered based on a time-stamp placed at the source (by RTI Connext or by the application).

    In any case this guarantees a consistent final value for the data in all subscribers.

    Note: If Batching is needed along with DDS.BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS and DDS.INSTANCE_SCOPE_DESTINATIONORDER_QOS, then the DDS.BatchQosPolicy.source_timestamp_resolution and DDS.BatchQosPolicy.thread_safe_write setting of DDS.BatchQosPolicy should be set to DDS_DURATION_ZERO and DDS.BOOLEAN_TRUE respectively.
    See also: PublisherDeleteDataWriter_warning

    INSTANCE_SCOPE_DESTINATIONORDER_QOS

    INSTANCE_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 0;

    TOPIC_SCOPE_DESTINATIONORDER_QOS

    TOPIC_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 1;

    DESTINATION_ORDER_QOS_POLICY_DEFAULT

    HISTORY_QOS_POLICY_NAME

    HISTORY_QOS_POLICY_NAME              : constant DDS.String := To_DDS_String ("History");

    Summary: Stringified human-readable name for DDS.HistoryQosPolicy

    KEEP_LAST_HISTORY_QOS

    KEEP_LAST_HISTORY_QOS                : constant HistoryQosPolicyKind := 0;

    Summary: [default] Keep the last depth samples.

    On the publishing side, RTI Connext will only attempt to keep the most recent depth samples of each instance of data (identified by its key) managed by the DDS.DataWriter. Invalid samples represeting a disposal or unregistration of an instance do not count towards the history depth.

    On the subscribing side, the DDS.DataReader will only attempt to keep the most recent depth samples received for each instance (identified by its key) until the application takes them via the DDS.DataReader 's take() operation.
    Invalid samples represeting a dispoasal or unregistration of an instance do count towards the history depth and may therefore replace a value of the instance currently being stored in the reader queue.

    KEEP_ALL_HISTORY_QOS

    KEEP_ALL_HISTORY_QOS                 : constant HistoryQosPolicyKind := 1;

    Summary: Keep all the samples.

    On the publishing side, RTI Connext will attempt to keep all samples (representing each value written) of each instance of data (identified by its key) managed by the DDS.DataWriter until they can be delivered to all subscribers.

    On the subscribing side, RTI Connext will attempt to keep all samples of each instance of data (identified by its key) managed by the DDS.DataReader. These samples are kept until the application takes them from RTI Connext via the take() operation.

    NONE_REFILTER_QOS

    NONE_REFILTER_QOS                    : constant RefilterQosPolicyKind := 0;

    Summary: [default] Do not filter existing samples for a new reader

    On the publishing side, when a new reader matches a writer, the writer can be configured to filter previously written samples stored in the writer queue for the new reader. This option configures the writer to not filter any existing samples for the reader and the reader will do the filtering.

    ALL_REFILTER_QOS

    ALL_REFILTER_QOS                     : constant RefilterQosPolicyKind := 1;

    Summary: Filter all existing samples for a new reader

    On the publishing side, when a new reader matches a writer, the writer can be configured to filter previously written samples stored in the writer queue. This option configures the writer to filter all existing samples for the reader when a new reader is matched to the writer.

    ON_DEMAND_REFILTER_QOS

    ON_DEMAND_REFILTER_QOS               : constant RefilterQosPolicyKind := 2;

    Summary: Filter existing samples only when they are requested by the reader

    On the publishing side, when a new reader matches a writer, the writer can be configured to filter previously written samples stored in the writer queue. This option configures the writer to filter only existing samples that are requested by the reader.

    HISTORY_QOS_POLICY_DEFAULT

    HISTORY_QOS_POLICY_DEFAULT           : constant HistoryQosPolicy :=
                                                (KEEP_LAST_HISTORY_QOS,
                                                 1,
                                                 NONE_REFILTER_QOS);

    LENGTH_UNLIMITED

    LENGTH_UNLIMITED                     : constant Long  := -1;

    Summary: A special value indicating an unlimited quantity.

    DURABILITYSERVICE_QOS_POLICY_NAME

    DURABILITYSERVICE_QOS_POLICY_NAME    : constant DDS.String := To_DDS_String ("DurabilityService");

    Summary: Stringified human-readable name for DDS.DurabilityQosPolicy

    DURABILITY_SERVICE_QOS_POLICY_DEFAULT

    RESOURCELIMITS_QOS_POLICY_NAME

    RESOURCELIMITS_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("ResourceLimits");

    Summary: Stringified human-readable name for DDS.ResourceLimitsQosPolicy

    RESOURCE_LIMITS_QOS_POLICY_DEFAULT

    RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant ResourceLimitsQosPolicy :=
                                              (LENGTH_UNLIMITED,
                                               LENGTH_UNLIMITED,
                                               LENGTH_UNLIMITED,
                                               32,
                                               32,
                                               32);

    TRANSPORTPRIORITY_QOS_POLICY_NAME

    TRANSPORTPRIORITY_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("TransportPriority");

    Summary: Stringified human-readable name for DDS.TransportPriorityQosPolicy

    TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT

    TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT : constant TransportPriorityQosPolicy :=
                                                 (Value => 0);

    LIFESPAN_QOS_POLICY_NAME

    LIFESPAN_QOS_POLICY_NAME              : constant DDS.String := To_DDS_String ("Lifespan");

    Summary: Stringified human-readable name for DDS.LifespanQosPolicy

    LIFESPAN_QOS_POLICY_DEFAULT

    LIFESPAN_QOS_POLICY_DEFAULT        : constant LifespanQosPolicy :=
                                              (Duration => DURATION_INFINITE);

    WRITERDATALIFECYCLE_QOS_POLICY_NAME

    WRITERDATALIFECYCLE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("WriterDataLifecycle");

    Summary: Stringified human-readable name for DDS.WriterDataLifecycleQosPolicy.

    WRITER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT

    WRITER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant WriterDataLifecycleQosPolicy :=
                                                    (Autodispose_Unregistered_Instances     => True,
                                                     Autopurge_Unregistered_Instances_Delay => DURATION_INFINITE,
                                                     Autopurge_Disposed_Instances_Delay     => DURATION_INFINITE);

    READERDATALIFECYCLE_QOS_POLICY_NAME

    READERDATALIFECYCLE_QOS_POLICY_NAME      : constant DDS.String := To_DDS_String ("ReaderDataLifecycle");

    Summary: Stringified human-readable name for DDS.ReaderDataLifecycleQosPolicy

    READER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT

    READER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant ReaderDataLifecycleQosPolicy :=
                                                    (Autopurge_Nowriter_Samples_Delay   => DURATION_INFINITE,
                                                     Autopurge_Disposed_Samples_Delay   => DURATION_INFINITE,
                                                     Autopurge_Disposed_Instances_Delay => DURATION_INFINITE);

    ENTITYFACTORY_QOS_POLICY_NAME

    ENTITYFACTORY_QOS_POLICY_NAME            : constant DDS.String := To_DDS_String ("EntityFactory");

    Summary: Stringified human-readable name for DDS.EntityFactoryQosPolicy.

    ENTITY_FACTORY_QOS_POLICY_DEFAULT

    ENTITY_FACTORY_QOS_POLICY_DEFAULT  : constant EntityFactoryQosPolicy :=
                                              (Autoenable_Created_Entities => True);

    RTPS_RELIABLE_READER_PROTOCOL_DEFAULT

    RTPS_RELIABLE_READER_PROTOCOL_DEFAULT : aliased constant RtpsReliableReaderProtocol_T :=
                                                 (Min_Heartbeat_Response_Delay       => (0, 0),
                                                  Max_Heartbeat_Response_Delay       => (0, 500_000_000),
                                                  Heartbeat_Suppression_Duration     => (0, 62_500_000),
                                                  Nack_Period                        => (5, 0),
                                                  Receive_Window_Size                => 256,
                                                  Round_Trip_Time                    => (0, 0),
                                                  App_Ack_Period                     => (5, 0),
                                                  Min_App_Ack_Response_Keep_Duration => (0, 0),
                                                  Samples_Per_App_Ack                => 1);

    RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT

    RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT :
       aliased  constant RtpsReliableReaderProtocol_T := (Min_Heartbeat_Response_Delay       => (0, 0),
                                                          Max_Heartbeat_Response_Delay       => (0, 0),
                                                          Heartbeat_Suppression_Duration     => (0, 62_500_000),
                                                          Nack_Period                        => (5, 0),
                                                          Receive_Window_Size                => 256,
                                                          Round_Trip_Time                    => (0, 0),
                                                          App_Ack_Period                     => (5, 0),
                                                          Min_App_Ack_Response_Keep_Duration => (0, 0),
                                                          Samples_Per_App_Ack                => 1);

    RTPS_PARTICIPANT_MESSAGE_READER_DISCOVERY_CONFIG_DEFAULT

    RTPS_PARTICIPANT_MESSAGE_READER_DISCOVERY_CONFIG_DEFAULT :
       aliased constant RtpsReliableReaderProtocol_T := (Min_Heartbeat_Response_Delay       => (0, 0),
                                                         Max_Heartbeat_Response_Delay       => (0, 0),
                                                         Heartbeat_Suppression_Duration     => (0, 62_500_000),
                                                         Nack_Period                        => (5, 0),
                                                         Receive_Window_Size                => 256,
                                                         Round_Trip_Time                    => (0, 0),
                                                         App_Ack_Period                     => (5, 0),
                                                         Min_App_Ack_Response_Keep_Duration => (0, 0),
                                                         Samples_Per_App_Ack                => 1);

    RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT

    RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT :
       constant RtpsReliableWriterProtocol_T := (Low_Watermark                                                    => 0,
                                                 High_Watermark                                                   => 1,
                                                 Heartbeat_Period                                                 => (3, 0),
                                                 Fast_Heartbeat_Period                                            => (3, 0),
                                                 Late_Joiner_Heartbeat_Period                                     => (3, 0),
                                                 Virtual_Heartbeat_Period                                         => DURATION_INFINITE,
                                                 Samples_Per_Virtual_Heartbeat                                    => -1,
                                                 Max_Heartbeat_Retries                                            => 10,
                                                 Inactivate_Nonprogressing_Readers                                => False,
                                                 Heartbeats_Per_Max_Samples                                       => 8,
                                                 Min_Nack_Response_Delay                                          => (0, 0),
                                                 Max_Nack_Response_Delay                                          => (0, 200_000_000),
                                                 Nack_Suppression_Duration                                        => (0, 0),
                                                 Max_Bytes_Per_Nack_Response                                      => 131072,
                                                 Disable_Positive_Acks_Min_Sample_Keep_Duration                   => (0, 1_000_000),
                                                 Disable_Positive_Acks_Max_Sample_Keep_Duration                   => (1, 0),
                                                 Disable_Positive_Acks_Sample_Min_Separation                      => (0, 100_000),
                                                 Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration       => True,
                                                 Disable_Positive_Acks_Enable_Spin_Wait                           => False,
                                                 Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor       => 0,
                                                 Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor       => 3,
                                                 Min_Send_Window_Size                                             => 32,
                                                 Max_Send_Window_Size                                             => 256,
                                                 Send_Window_Update_Period                                        => (3, 0),
                                                 Send_Window_Increase_Factor                                      => 105,
                                                 Send_Window_Decrease_Factor                                      => 70,
                                                 Enable_Multicast_Periodic_Heartbeat                              => False,
                                                 Multicast_Resend_Threshold                                       => 2
                                                );

    RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT

    RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT  :
       constant RtpsReliableWriterProtocol_T := (Low_Watermark                                                      => 0,
                                                 High_Watermark                                                     => 1,
                                                 Heartbeat_Period                                                   => (3, 0),
                                                 Fast_Heartbeat_Period                                              => (3, 0),
                                                 Late_Joiner_Heartbeat_Period                                       => (3, 0),
                                                 Virtual_Heartbeat_Period                                           => DURATION_INFINITE,
                                                 Samples_Per_Virtual_Heartbeat                                      => -1,
                                                 Max_Heartbeat_Retries                                              => 10,
                                                 Inactivate_Nonprogressing_Readers                                  => False,
                                                 Heartbeats_Per_Max_Samples                                         => 8,
                                                 Min_Nack_Response_Delay                                            => (0, 0),
                                                 Max_Nack_Response_Delay                                            => (0, 0),
                                                 Nack_Suppression_Duration                                          => (0, 0),
                                                 Max_Bytes_Per_Nack_Response                                        => 131072,
                                                 Disable_Positive_Acks_Min_Sample_Keep_Duration                     => (0, 1_000_000),
                                                 Disable_Positive_Acks_Max_Sample_Keep_Duration                     => (1, 0),
                                                 Disable_Positive_Acks_Sample_Min_Separation                        => (0, 100_000),
                                                 Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration         => True,
                                                 Disable_Positive_Acks_Enable_Spin_Wait                             => False,
                                                 Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor         => 95,
                                                 Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor         => 150,
                                                 Min_Send_Window_Size                                               => -1,
                                                 Max_Send_Window_Size                                               => -1,
                                                 Send_Window_Update_Period                                          => (3, 0),
                                                 Send_Window_Increase_Factor                                        => 105,
                                                 Send_Window_Decrease_Factor                                        => 50,
                                                 Enable_Multicast_Periodic_Heartbeat                                => False,
                                                 Multicast_Resend_Threshold                                         => 2
                                                );

    RTPS_PARTICIPANT_MESSAGE_WRITER_DISCOVERY_CONFIG_DEFAULT

    RTPS_PARTICIPANT_MESSAGE_WRITER_DISCOVERY_CONFIG_DEFAULT  :
       constant RtpsReliableWriterProtocol_T := (Low_Watermark                                                      => 0,
                                                 High_Watermark                                                     => 1,
                                                 Heartbeat_Period                                                   => (1, 0),
                                                 Fast_Heartbeat_Period                                              => (1, 0),
                                                 Late_Joiner_Heartbeat_Period                                       => (1, 0),
                                                 Virtual_Heartbeat_Period                                           => DURATION_INFINITE,
                                                 Samples_Per_Virtual_Heartbeat                                      => -1,
                                                 Max_Heartbeat_Retries                                              => 10,
                                                 Inactivate_Nonprogressing_Readers                                  => False,
                                                 Heartbeats_Per_Max_Samples                                         => 1,
                                                 Min_Nack_Response_Delay                                            => (0, 0),
                                                 Max_Nack_Response_Delay                                            => (0, 0),
                                                 Nack_Suppression_Duration                                          => (0, 0),
                                                 Max_Bytes_Per_Nack_Response                                        => 9216,
                                                 Disable_Positive_Acks_Min_Sample_Keep_Duration                     => (0, 1_000_000),
                                                 Disable_Positive_Acks_Max_Sample_Keep_Duration                     => (1, 0),
                                                 Disable_Positive_Acks_Sample_Min_Separation                        => (0, 100_000),
                                                 Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration         => True,
                                                 Disable_Positive_Acks_Enable_Spin_Wait                             => False,
                                                 Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor         => 95,
                                                 Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor         => 150,
                                                 Min_Send_Window_Size                                               => -1,
                                                 Max_Send_Window_Size                                               => -1,
                                                 Send_Window_Update_Period                                          => (1, 0),
                                                 Send_Window_Increase_Factor                                        => 105,
                                                 Send_Window_Decrease_Factor                                        => 50,
                                                 Enable_Multicast_Periodic_Heartbeat                                => False,
                                                 Multicast_Resend_Threshold                                         => 2
                                                );

    ENCAPSULATION_ID_CDR_BE

    ENCAPSULATION_ID_CDR_BE : constant EncapsulationId_T := 0;

    ENCAPSULATION_ID_CDR_LE

    ENCAPSULATION_ID_CDR_LE : constant EncapsulationId_T := 1;

    ENCAPSULATION_ID_CDR_NATIVE

    ENCAPSULATION_ID_CDR_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);

    TRANSPORTSELECTION_QOS_POLICY_NAME

    TRANSPORTSELECTION_QOS_POLICY_NAME : constant DDS.String  := To_DDS_String ("TransportSelection");

    Summary: Stringified human-readable name for DDS.TransportSelectionQosPolicy

    TRANSPORTUNICAST_QOS_POLICY_NAME

    TRANSPORTUNICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportUnicast");

    Summary: Stringified human-readable name for DDS.TransportUnicastQosPolicy

    TRANSPORTMULTICAST_QOS_POLICY_NAME

    TRANSPORTMULTICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticast");

    Summary: Stringified human-readable name for DDS.TransportMulticastQosPolicy

    AUTOMATIC_TRANSPORT_MULTICAST_QOS

    AUTOMATIC_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 0;

    Summary: Selects the multicast address automatically

    NOTE: This setting is required when using the DDS.TransportMulticastMappingQosPolicy.

    UNICAST_ONLY_TRANSPORT_MULTICAST_QOS

    UNICAST_ONLY_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 1;

    Summary: Selects a unicast-only mode

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticastMapping");

    Summary: Stringified human-readable name for DDS.TransportMulticastMappingQosPolicy

    TRANSPORTENCAPSULATION_QOS_POLICY_NAME

    TRANSPORTENCAPSULATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportEncapsulation");

    DISCOVERY_QOS_POLICY_NAME

    DISCOVERY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Discovery");

    Summary: Stringified human-readable name for DDS.DiscoveryQosPolicy

    TRANSPORTBUILTIN_QOS_POLICY_NAME

    TRANSPORTBUILTIN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportBuiltin");

    Summary: Stringified human-readable name for DDS.TransportBuiltinQosPolicy

    TRANSPORTBUILTIN_UDPv4

    TRANSPORTBUILTIN_UDPv4 : constant TransportBuiltinKind := 2 ** 0;

    Summary: Built-in UDPv4 transport, NDDS_Transport_UDPv4_Plugin

    TRANSPORTBUILTIN_SHMEM

    TRANSPORTBUILTIN_SHMEM : constant TransportBuiltinKind := 2 ** 1;

    Summary: Built-in shared memory transport, NDDS_Transport_Shmem_Plugin

    TRANSPORTBUILTIN_INTRA

    TRANSPORTBUILTIN_INTRA : constant TransportBuiltinKind := 2 ** 2;

    TRANSPORTBUILTIN_UDPv6

    TRANSPORTBUILTIN_UDPv6 : constant TransportBuiltinKind := 2 ** 3;

    Summary: Built-in UDPv6 transport, NDDS_Transport_UDPv6_Plugin

    TRANSPORTBUILTIN_INTRA_ALIAS

    TRANSPORTBUILTIN_INTRA_ALIAS : constant DDS.String := To_DDS_String ("builtin.intra");

    TRANSPORTBUILTIN_SHMEM_ALIAS

    TRANSPORTBUILTIN_SHMEM_ALIAS : constant DDS.String := To_DDS_String ("builtin.shmem");

    Summary: Alias name for the shared memory built-in transport

    TRANSPORTBUILTIN_UDPv4_ALIAS

    TRANSPORTBUILTIN_UDPv4_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv4");

    Summary: Alias name for the UDPv4 built-in transport

    TRANSPORTBUILTIN_UDPv6_ALIAS

    TRANSPORTBUILTIN_UDPv6_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv");

    Summary: Alias name for the UDPv6 built-in transport

    TRANSPORTBUILTIN_MASK_NONE

    TRANSPORTBUILTIN_MASK_NONE : constant TransportBuiltinKindMask := 0;

    Summary: None of the built-in transports will be registered automatically when the DDS.DomainParticipant is enabled.

    The user must explictly register transports using NDDSTransportSupport.register_transport.


    See also: DDS.TransportBuiltinKindMask

    TRANSPORTBUILTIN_MASK_DEFAULT

    TRANSPORTBUILTIN_MASK_DEFAULT : constant TransportBuiltinKindMask :=
                                         (TRANSPORTBUILTIN_UDPv4 or TRANSPORTBUILTIN_SHMEM);

    Summary: The default value of DDS.TransportBuiltinQosPolicy.mask.

    The set of builtin transport plugins that will be automatically registered with the participant by default. The user can register additional transports using NDDSTransportSupport.register_transport.

    [default] [UDPv4|Shmem]


    See also: DDS.TransportBuiltinKindMask

    TRANSPORTBUILTIN_MASK_ALL

    TRANSPORTBUILTIN_MASK_ALL  : constant TransportBuiltinKindMask := 16#FFFF_FFFF#;

    Summary: All the available built-in transports are registered automatically when the DDS.DomainParticipant is enabled.


    See also: DDS.TransportBuiltinKindMask

    TRANSPORT_BUILTIN_QOS_POLICY_DEFAULT

    TRANSPORT_BUILTIN_QOS_POLICY_DEFAULT : constant TransportBuiltinQosPolicy :=
                                                (Mask => TRANSPORTBUILTIN_MASK_DEFAULT);

    RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS

    RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T
         := (Port_Base                     =>  7400,
             Domain_Id_Gain                =>  10,
             Participant_Id_Gain           =>  1000,
             Builtin_Multicast_Port_Offset =>  2,
             Builtin_Unicast_Port_Offset   =>  0,
             User_Multicast_Port_Offset    =>  1,
             User_Unicast_Port_Offset      =>  3);

    Summary: Assign to use well-known port mappings which are compatible with previous versions of the RTI Connext middleware.

    Assign DDS.WireProtocolQosPolicy.rtps_well_known_ports to this value to remain compatible with previous versions of the RTI Connext middleware that used fixed port mappings.

    The following are the rtps_well_known_ports values for DDS.RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS:

    port_base = 7400
    domain_id_gain = 10
    participant_id_gain = 1000
    builtin_multicast_port_offset = 2
    builtin_unicast_port_offset = 0
    user_multicast_port_offset = 1
    user_unicast_port_offset = 3

    These settings are not compliant with OMG's DDS Interoperability Wire Protocol. To comply with the specification, please use DDS.INTEROPERABLE_RTPS_WELL_KNOWN_PORTS.


    See also: DDS.WireProtocolQosPolicy.rtps_well_known_ports
    See also: DDS.INTEROPERABLE_RTPS_WELL_KNOWN_PORTS

    INTEROPERABLE_RTPS_WELL_KNOWN_PORTS

    INTEROPERABLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T
         := (Port_Base                     =>  7400,
             Domain_Id_Gain                =>  250,
             Participant_Id_Gain           =>  2,
             Builtin_Multicast_Port_Offset =>  0,
             Builtin_Unicast_Port_Offset   =>  10,
             User_Multicast_Port_Offset    =>  1,
             User_Unicast_Port_Offset      =>  11);

    Summary: Assign to use well-known port mappings which are compliant with OMG's DDS Interoperability Wire Protocol.

    Assign DDS.WireProtocolQosPolicy.rtps_well_known_ports to this value to use well-known port mappings which are compliant with OMG's DDS Interoperability Wire Protocol.

    The following are the rtps_well_known_ports values for DDS.INTEROPERABLE_RTPS_WELL_KNOWN_PORTS:

    port_base = 7400
    domain_id_gain = 250
    participant_id_gain = 2
    builtin_multicast_port_offset = 0
    builtin_unicast_port_offset = 10
    user_multicast_port_offset = 1
    user_unicast_port_offset = 11

    Assuming a maximum port number of 65535 (UDPv4), the above settings enable the use of about 230 domains with up to 120 Participants per node per domain.

    These settings are not backwards compatible with previous versions of the RTI Connext middleware that used fixed port mappings. For backwards compability, please use DDS.RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS.


    See also: DDS.WireProtocolQosPolicy.rtps_well_known_ports
    See also: DDS.RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS

    RTPS_WELL_KNOWN_PORTS_DEFAULT

    RTPS_WELL_KNOWN_PORTS_DEFAULT : constant RtpsWellKnownPorts_T :=
                                         (Port_Base                     => 7400,
                                          Domain_Id_Gain                => 10,
                                          Participant_Id_Gain           => 1000,
                                          Builtin_Multicast_Port_Offset => 2,
                                          Builtin_Unicast_Port_Offset   => 0,
                                          User_Multicast_Port_Offset    => 1,
                                          User_Unicast_Port_Offset      => 3);

    RTPS_RESERVED_PORT_BUILTIN_UNICAST

    RTPS_RESERVED_PORT_BUILTIN_UNICAST   : constant RtpsReservedPortKind := 2#0001#;

    Summary: Select the metatraffic unicast port.

    RTPS_RESERVED_PORT_BUILTIN_MULTICAST

    RTPS_RESERVED_PORT_BUILTIN_MULTICAST : constant RtpsReservedPortKind := 2#0010#;

    Summary: Select the metatraffic multicast port.

    RTPS_RESERVED_PORT_USER_UNICAST

    RTPS_RESERVED_PORT_USER_UNICAST      : constant RtpsReservedPortKind := 2#0100#;

    Summary: Select the usertraffic unicast port.

    RTPS_RESERVED_PORT_USER_MULTICAST

    RTPS_RESERVED_PORT_USER_MULTICAST    : constant RtpsReservedPortKind := 2#1000#;

    Summary: Select the usertraffic multicast port.

    RTPS_RESERVED_PORT_MASK_DEFAULT

    Summary: The default value of DDS.WireProtocolQosPolicy.rtps_reserved_port_mask.

    Most of the ports that may be needed by DDS will be reserved by the transport when the participant is enabled. With this value set, failure to allocate a port that is computed based on the DDS.RtpsWellKnownPorts_t will be detected at this time and the enable operation will fail.

    This setting will avoid reserving the usertraffic multicast port, which is not actually used unless there are DataReaders that enable multicast but fail to specify a port.

    Automatic participant ID selection will be based on finding a participant index with both the discovery (metatraffic) unicast port and usertraffic unicast port available.


    See also: DDS.RtpsReservedPortKindMask

    RTPS_RESERVED_PORT_MASK_NONE

    RTPS_RESERVED_PORT_MASK_NONE  : constant RtpsReservedPortKindMask := 0;

    Summary: No bits are set.

    None of the ports that are needed by DDS will be allocated until they are specifically required. With this value set, automatic participant Id selection will be based on selecting a port for discovery (metatraffic) unicast traffic on a single transport.


    See also: DDS.RtpsReservedPortKindMask

    RTPS_RESERVED_PORT_MASK_ALL

    RTPS_RESERVED_PORT_MASK_ALL   : constant RtpsReservedPortKindMask := 16#FFFF_FFFF#;

    Summary: All bits are set.

    All of the ports that may be needed by DDS will be reserved when the participant is enabled. With this value set, failure to allocate a port that is computed based on the DDS.RtpsWellKnownPorts_t will be detected at this time, and the enable operation will fail.

    Note that this will also reserve the usertraffic multicast port which is not actually used unless there are DataReaders that enable multicast but fail to specify a port. To avoid unnecesary resource usage for these ports, use RTPS_RESERVED_PORT_MASK_DEFAULT.

    Automatic participant ID selection will be based on finding a participant index with both the discovery (metatraffic) unicast port and usertraffic unicast port available.


    See also: DDS.RtpsReservedPortKindMask

    WIREPROTOCOL_QOS_POLICY_NAME

    WIREPROTOCOL_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("WireProtocol");

    Summary: Stringified human-readable name for DDS.WireProtocolQosPolicy

    RTPS_AUTO_ID_FROM_IP

    RTPS_AUTO_ID_FROM_IP : constant WireProtocolQosPolicyAutoKind := 0;

    Summary: Select the IPv4 based algorithm.

    RTPS_AUTO_ID_FROM_MAC

    RTPS_AUTO_ID_FROM_MAC : constant WireProtocolQosPolicyAutoKind := 1;

    Summary: Select the MAC based algorithm.

    Note to Solaris Users: To use DDS_RTPS_AUTO_ID_FROM_MAC, you must run the RTI Connext application while logged in as 'root.'

    RTPS_AUTO_ID

    RTPS_AUTO_ID    : constant Unsigned_Long := 0;

    WIRE_PROTOCOL_QOS_POLICY_DEFAULT

    WIRE_PROTOCOL_QOS_POLICY_DEFAULT : constant WireProtocolQosPolicy :=
                                            (Participant_Id          => -1, -- Automatic
                                             Rtps_Host_Id            => RTPS_AUTO_ID,
                                             Rtps_App_Id             => RTPS_AUTO_ID,
                                             Rtps_Instance_Id        => RTPS_AUTO_ID,
                                             Rtps_Well_Known_Ports   => RTPS_WELL_KNOWN_PORTS_DEFAULT,
                                             Rtps_Reserved_Port_Mask => 2#0000_0000_0000_0000#,
                                             Rtps_Auto_Id_Kind       => RTPS_AUTO_ID_FROM_IP,
                                             compute_crc             => False,
                                             check_crc               => False);

    LOCATOR_ADDRESS_LENGTH_MAX

    LOCATOR_ADDRESS_LENGTH_MAX  : constant Unsigned_Long := 16;

    Summary: Declares length of address field in locator.

    LOCATOR_INVALID

    LOCATOR_INVALID : constant Locator_T :=
                           (Kind           => -1,
                            Port           => 0,
                            Address        => (others => 00),
                            Encapsulations => EncapsulationId_Seq.DEFAULT_SEQUENCE);

    Summary: An invalid locator.

    LOCATOR_KIND_INVALID

    LOCATOR_KIND_INVALID : constant Long := -1;

    Summary: Locator of this kind is invalid.

    LOCATOR_PORT_INVALID

    LOCATOR_PORT_INVALID : constant Unsigned_Long := 0;

    Summary: An invalid port.

    LOCATOR_ADDRESS_INVALID

    LOCATOR_ADDRESS_INVALID : constant Locator_Address_Array_T := (others => 0);

    Summary: An invalid address.

    LOCATOR_KIND_ANY

    LOCATOR_KIND_ANY : constant Long := 0;

    LOCATOR_KIND_UDPv4

    LOCATOR_KIND_UDPv4 : constant Long := 1;

    Summary: A locator for a UDPv4 address.

    LOCATOR_KIND_SHMEM

    LOCATOR_KIND_SHMEM  : constant Long := 2;

    Summary: A locator for an address acessed via shared memory.

    LOCATOR_KIND_INTRA

    LOCATOR_KIND_INTRA  : constant Long := 3;

    LOCATOR_KIND_UDPv6

    LOCATOR_KIND_UDPv6 : constant Long := 5;

    Summary: A locator for a UDPv6 address.

    LOCATOR_KIND_DTLS

    LOCATOR_KIND_DTLS : constant Long := 6;

    LOCATOR_KIND_WAN

    LOCATOR_KIND_WAN : constant Long := 7;

    LOCATOR_KIND_TCPV4_LAN

    LOCATOR_KIND_TCPV4_LAN : constant Long := 8;

    LOCATOR_KIND_TCPV4_WAN

    LOCATOR_KIND_TCPV4_WAN : constant Long := 9;

    LOCATOR_KIND_TLSV4_LAN

    LOCATOR_KIND_TLSV4_LAN : constant Long := 10;

    LOCATOR_KIND_TLSV4_WAN

    LOCATOR_KIND_TLSV4_WAN : constant Long := 11;

    LOCATOR_KIND_RESERVED

    LOCATOR_KIND_RESERVED : constant Long := 1000;

    Summary: Locator of this kind is reserved.

    PROTOCOL_VERSION_DEFAULT

    PROTOCOL_VERSION_DEFAULT : constant ProtocolVersion_T :=
                                    (Major => 0,
                                     Minor => 0);

    PROTOCOLVERSION_1_0

    PROTOCOLVERSION_1_0      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 0);

    Summary: The protocol version 1.0

    PROTOCOLVERSION_1_1

    PROTOCOLVERSION_1_1      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 1);

    Summary: The protocol version 1.1

    PROTOCOLVERSION_1_2

    PROTOCOLVERSION_1_2      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 2);

    Summary: The protocol version 1.2

    PROTOCOLVERSION_2_0

    PROTOCOLVERSION_2_0      : constant ProtocolVersion_T :=
                                    (Major => 2,
                                     Minor => 0);

    Summary: The protocol version 2.0

    PROTOCOLVERSION_2_1

    PROTOCOLVERSION_2_1      : constant ProtocolVersion_T :=
                                    (Major => 2,
                                     Minor => 1);

    Summary: The protocol version 2.1

    PROTOCOLVERSION

    PROTOCOLVERSION          : constant ProtocolVersion_T :=
                                    (Major => 2,
                                     Minor => 1);

    Summary: The most recent protocol version. Currently 2.1.

    VENDOR_ID_LENGTH_MAX

    VENDOR_ID_LENGTH_MAX     : constant := 2;

    Summary: Length of vendor id.

    VENDOR_ID_DEFAULT

    VENDOR_ID_DEFAULT : constant  VendorId_T := (VendorId => (0, 0));

    VENDORID_UNKNOWN

    VENDORID_UNKNOWN  : constant  VendorId_T := (VendorId => (0, 0));

    PRODUCTVERSION_UNKNOWN

    PRODUCTVERSION_UNKNOWN : constant ProductVersion_T :=
                                  (Major    => Char (ASCII.NUL),
                                   Minor    => Char (ASCII.NUL),
                                   Release  => '0',
                                   Revision => Char (ASCII.NUL));

    Summary: The value used when the product version is unknown.

    DATAREADERRESOURCELIMITS_QOS_POLICY_NAME

    DATAREADERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderResourceLimits");

    Summary: Stringified human-readable name for DDS.DataReaderResourceLimitsQosPolicy

    AUTO_MAX_TOTAL_INSTANCES

    AUTO_MAX_TOTAL_INSTANCES : constant Long := 0;

    Summary: <<ext>> This value is used to make DDS.DataReaderResourceLimitsQosPolicy.max_total_instances equal to DDS.ResourceLimitsQosPolicy.max_instances.

    DATA_READER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT

    DATA_READER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT :   constant DataReaderResourceLimitsQosPolicy :=
                                                          (Max_Remote_Writers                          => -1,
                                                           Max_Remote_Writers_Per_Instance             => -1,
                                                           Max_Samples_Per_Remote_Writer               => -1,
                                                           Max_Infos                                   => -1,
                                                           Initial_Remote_Writers                      =>  2,
                                                           Initial_Remote_Writers_Per_Instance         => 2,
                                                           Initial_Infos                               => 32,
                                                           Initial_Outstanding_Reads                   => 2,
                                                           Max_Outstanding_Reads                       =>  -1,
                                                           Max_Samples_Per_Read                        =>  1024,
                                                           Disable_Fragmentation_Support               =>  False,
                                                           Max_Fragmented_Samples                      =>  1024,
                                                           Initial_Fragmented_Samples                  =>  4,
                                                           Max_Fragmented_Samples_Per_Remote_Writer    =>  256,
                                                           Max_Fragments_Per_Sample                    =>  512,
                                                           Dynamically_Allocate_Fragmented_Samples     => False,
                                                           Max_Total_Instances                         => 32,
                                                           Max_Remote_Virtual_Writers                  => -1,
                                                           Initial_Remote_Virtual_Writers              => 2,
                                                           Max_Remote_Virtual_Writers_Per_Instance     => -1,
                                                           Initial_Remote_Virtual_Writers_Per_Instance => 2,
                                                           Max_Remote_Writers_Per_Sample               => 3,
                                                           Max_Query_Condition_Filters                 => 4,
                                                           Max_App_Ack_Response_Length                 => 0,
                                                           Keep_Minimum_State_For_Instances            => True,
                                                           Initial_Topic_Queries                       => 1,
                                                           Max_Topic_Queries                           => -1);

    DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME

    DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME       : constant DDS.String := To_DDS_String ("DataWriterResourceLimits");

    Summary: Stringified human-readable name for DDS.DataWriterResourceLimitsQosPolicy

    UNREGISTERED_INSTANCE_REPLACEMENT

    UNREGISTERED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 0;

    Summary: Allows a DDS.DataWriter to reclaim unregistered acknowledged instances.

    By default, all instance replacement kinds first attempt to reclaim an unregistered, acknowledged instance. Used in DDS.DataWriterResourceLimitsQosPolicy.instance_replacement [default]

    ALIVE_INSTANCE_REPLACEMENT

    ALIVE_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 1;

    Summary: Allows a DDS.DataWriter to reclaim alive, acknowledged instances.

    When an unregistered, acknowledged instance is not available to reclaim, this kind allows a DDS.DataWriter to reclaim an alive, acknowledged instance, where an alive instance is a registered, non-disposed instance. The least recently registered or written alive instance will be reclaimed.

    DISPOSED_INSTANCE_REPLACEMENT

    DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 2;

    Summary: Allows a DDS.DataWriter to reclaim disposed acknowledged instances.

    When an unregistered, acknowledged instance is not available to reclaim, this kind allows a DDS.DataWriter to reclaim a disposed, acknowledged instance. The least recently disposed instance will be reclaimed.

    ALIVE_THEN_DISPOSED_INSTANCE_REPLACEMENT

    ALIVE_THEN_DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 3;

    Summary: Allows a DDS.DataWriter first to reclaim an alive, acknowledged instance, and then, if necessary, a disposed, acknowledged instance.

    When an unregistered, acknowledged instance is not available to reclaim, this kind allows a DDS.DataWriter to first try reclaiming an alive, acknowledged instance. If no instance is reclaimable, then it tries reclaiming a disposed, acknowledged instance. The least recently used (i.e., registered, written, or disposed) instance will be reclaimed.

    DISPOSED_THEN_ALIVE_INSTANCE_REPLACEMENT

    DISPOSED_THEN_ALIVE_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 4;

    Summary: Allows a DDS.DataWriter first to reclaim a disposed, acknowledged instance, and then, if necessary, an alive, acknowledged instance.

    When an unregistered, acknowledged instance is not available to reclaim, this kind allows a DDS.DataWriter to first try reclaiming a disposed, acknowledged instance. If no instance is reclaimable, then it tries reclaiming an alive, acknowledged instance. The least recently used (i.e., disposed, registered, or written) instance will be reclaimed.

    ALIVE_OR_DISPOSED_INSTANCE_REPLACEMENT

    ALIVE_OR_DISPOSED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 5;

    Summary: Allows a DDS.DataWriter to reclaim a either an alive acknowledged instance or a disposed acknowledged instance.

    When an unregistered acknowledged instance is not available to reclaim, this kind allows a DDS.DataWriter to reclaim either an alive, acknowledged instance or a disposed, acknowledged instance. If both instance kinds are available to reclaim, the DDS.DataWriter will reclaim the least recently used (i.e. disposed, registered, or written) instance.

    DATA_WRITER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT

    DATA_WRITER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DataWriterResourceLimitsQosPolicy :=
                                                          (Initial_Concurrent_Blocking_Threads => 1,
                                                           Max_Concurrent_Blocking_Threads     => -1,
                                                           Max_Remote_Reader_Filters           => 32,
                                                           Initial_Batches                     => 8,
                                                           Max_Batches                         => -1,
                                                           Cookie_Max_Length                   => -1,
                                                           Instance_Replacement                => UNREGISTERED_INSTANCE_REPLACEMENT,
                                                           Replace_Empty_Instances             => False,
                                                           Autoregister_Instances              => False,
                                                           Initial_Virtual_Writers             =>  1,
                                                           Max_Virtual_Writers                 => -1,
                                                           Max_Remote_Readers                  => -1,
                                                           Max_App_Ack_Remote_Readers          => -1,
                                                           Initial_Active_Topic_Queries        =>  1,
                                                           Max_Topic_Queries                   => -1);

    SERVICE_QOS_POLICY_NAME

    SERVICE_QOS_POLICY_NAME                        : constant DDS.String := To_DDS_String ("Service");

    NO_SERVICE_QOS

    NO_SERVICE_QOS : constant ServiceQosPolicyKind := 0;

    Summary: There is no service associated with the entity.

    PERSISTENCE_SERVICE_QOS

    PERSISTENCE_SERVICE_QOS : constant ServiceQosPolicyKind := 1;

    Summary: The entity is an entity created by RTI Persistence Service.

    QUEUING_SERVICE_QOS

    QUEUING_SERVICE_QOS : constant ServiceQosPolicyKind := 2;

    Summary: The entity is an entity created by RTI Queuing Service.

    ROUTING_SERVICE_QOS

    ROUTING_SERVICE_QOS : constant ServiceQosPolicyKind := 3;

    Summary: The entity is an entity created by RTI Routing Service.

    RECORDING_SERVICE_QOS

    RECORDING_SERVICE_QOS : constant ServiceQosPolicyKind := 4;

    Summary: The entity is an entity created by RTI Recording Service.

    REPLAY_SERVICE_QOS

    REPLAY_SERVICE_QOS : constant ServiceQosPolicyKind := 5;

    Summary: The entity is an entity created by RTI Replay Service.

    DATABASE_INTEGRATION_SERVICE_QOS

    DATABASE_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 6;

    Summary: The entity is an entity created by RTI Database Integration Service.

    DDS_WEB_INTEGRATION_SERVICE_QOS

    DDS_WEB_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 7;
    TODO: Add Docs

    SERVICE_QOS_POLICY_DEFAULT

    SERVICE_QOS_POLICY_DEFAULT : constant ServiceQosPolicy :=
                                      (Kind => NO_SERVICE_QOS);

    PUBLISHERPROTOCOL_QOS_POLICY_NAME

    PUBLISHERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublisherProtocol");

    PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT

    PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT : constant PublisherProtocolQosPolicy :=
                                                 (Vendor_Specific_Entity => False);

    SUBSCRIBERPROTOCOL_QOS_POLICY_NAME

    SUBSCRIBERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SubscriberProtocol");

    SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT

    SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT : constant SubscriberProtocolQosPolicy :=
                                                  (Vendor_Specific_Entity => False);

    DATAREADERPROTOCOL_QOS_POLICY_NAME

    DATAREADERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderProtocol");

    Summary: Stringified human-readable name for DDS.DataReaderProtocolQosPolicy

    DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT

    DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataReaderProtocolQosPolicy :=
                                                   (Virtual_Guid                                => (Value => (others => 0)),
                                                    Rtps_Object_Id                              => RTPS_AUTO_ID,
                                                    Expects_Inline_Qos                          => False,
                                                    Disable_Positive_Acks                       => False,
                                                    Propagate_Dispose_Of_Unregistered_Instances => False,
                                                    Propagate_Unregister_Of_Disposed_Instances  => False,
                                                    Rtps_Reliable_Reader                        => RTPS_RELIABLE_READER_PROTOCOL_DEFAULT,
                                                    Vendor_Specific_Entity                      => False,
                                                    Meta_Entity                                 => False);

    DATAWRITERPROTOCOL_QOS_POLICY_NAME

    DATAWRITERPROTOCOL_QOS_POLICY_NAME      : constant DDS.String := To_DDS_String ("DataWriterProtocol");

    Summary: Stringified human-readable name for DDS.DataWriterProtocolQosPolicy

    DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT

    DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataWriterProtocolQosPolicy :=
                                                   (Virtual_Guid                       => (Value => (others => 0)),
                                                    Rtps_Object_Id                     => RTPS_AUTO_ID,
                                                    Push_On_Write                      => True,
                                                    Disable_Positive_Acks              => False,
                                                    Disable_Inline_Keyhash             => False,
                                                    Serialize_Key_With_Dispose         => False,
                                                    Propagate_App_Ack_With_No_Response => True,
                                                    Rtps_Reliable_Writer               => RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT,
                                                    Initial_Virtual_Sequence_Number    => (-2147483648, 16#FFFF_FFFF#),
                                                    Vendor_Specific_Entity             => False);

    SYSTEMRESOURCELIMITS_QOS_POLICY_NAME

    SYSTEMRESOURCELIMITS_QOS_POLICY_NAME    : constant DDS.String := To_DDS_String ("SystemResourceLimits");

    Summary: Stringified human-readable name for DDS.SystemResourceLimitsQosPolicy

    SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT

    SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant SystemResourceLimitsQosPolicy :=
                                                     (Max_Objects_Per_Thread => 1024);

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME :  constant DDS.String := To_DDS_String ("DomainParticipantResourceLimits");

    Summary: Stringified human-readable name for DDS.DomainParticipantResourceLimitsQosPolicy

    DomainParticipantResourceLimitsQosPolicy_MATCH_INIT

    DomainParticipantResourceLimitsQosPolicy_MATCH_INIT : constant DDS.Long := 32;

    NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT

    NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT :
       constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 0;

    Summary: Default value for ignored_entity_replacement_kind, no replacement is done, the ignore will fail if the ignored_entity table is full.

    DDS_NOT_ALIVE_FIRST_IGNORED_ENTITY_REPLACEMENT

    DDS_NOT_ALIVE_FIRST_IGNORED_ENTITY_REPLACEMENT :
       constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 1;

    Summary: If the ignored_entity table is full and if there is at least one ignored participant in the table, the participant record that has been not updated for the longest time will be replaced.

    Note that if the table is full and there are no participant records to replace, the ignore will fail.

    DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT

    DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT :
       constant DomainParticipantResourceLimitsQosPolicy :=
                                                                 (Local_Writer_Allocation                               => (16, -1, -1),
                                                                  Local_Reader_Allocation                               => (16, -1, -1),
                                                                  Local_Publisher_Allocation                            => (4, -1, -1),
                                                                  Local_Subscriber_Allocation                           => (4, -1, -1),
                                                                  Local_Topic_Allocation                                => (16, -1, -1),
                                                                  Remote_Writer_Allocation                              => (64, -1, -1),
                                                                  Remote_Reader_Allocation                              => (64, -1, -1),
                                                                  Remote_Participant_Allocation                         => (16, -1, -1),
                                                                  Matching_Writer_Reader_Pair_Allocation                =>
                                                                    (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1),
                                                                  Matching_Reader_Writer_Pair_Allocation                =>
                                                                    (DomainParticipantResourceLimitsQosPolicy_MATCH_INIT, -1, -1),
                                                                  Ignored_Entity_Allocation                             => (8, -1, -1),
                                                                  Content_Filtered_Topic_Allocation                     => (4, -1, -1),
                                                                  Content_Filter_Allocation                             => (4, -1, -1),
                                                                  Read_Condition_Allocation                             => (4, -1, -1),
                                                                  Query_Condition_Allocation                            => (4, -1, -1),
                                                                  Outstanding_Asynchronous_Sample_Allocation            => (64, -1, -1),
                                                                  Flow_Controller_Allocation                            => (4, -1, -1),
                                                                  Local_Writer_Hash_Buckets                             => 4,
                                                                  Local_Reader_Hash_Buckets                             => 4,
                                                                  Local_Publisher_Hash_Buckets                          => 1,
                                                                  Local_Subscriber_Hash_Buckets                         => 1,
                                                                  Local_Topic_Hash_Buckets                              => 4,
                                                                  Remote_Writer_Hash_Buckets                            => 16,
                                                                  Remote_Reader_Hash_Buckets                            => 16,
                                                                  Remote_Participant_Hash_Buckets                       => 4,
                                                                  Matching_Writer_Reader_Pair_Hash_Buckets              => 32,
                                                                  Matching_Reader_Writer_Pair_Hash_Buckets              => 32,
                                                                  Ignored_Entity_Hash_Buckets                           => 1,
                                                                  Content_Filtered_Topic_Hash_Buckets                   => 1,
                                                                  Content_Filter_Hash_Buckets                           => 1,
                                                                  Flow_Controller_Hash_Buckets                          => 1,
                                                                  Max_Gather_Destinations                               => 8,
                                                                  Participant_User_Data_Max_Length                      => 256,
                                                                  Inter_Participant_Data_Max_Length                     => 256,
                                                                  Topic_Data_Max_Length                                 => 256,
                                                                  Publisher_Group_Data_Max_Length                       => 256,
                                                                  Subscriber_Group_Data_Max_Length                      => 256,
                                                                  Writer_User_Data_Max_Length                           => 256,
                                                                  Reader_User_Data_Max_Length                           => 256,
                                                                  Max_Partitions                                        => 64,
                                                                  Max_Partition_Cumulative_Characters                   => 256,
                                                                  Default_Partition_Matches_All                         => False,
                                                                  Allow_No_Partitions                                   => False,
                                                                  Type_Code_Max_Serialized_Length                       => 2048,
                                                                  Type_Object_Max_Serialized_Length                     => 2048,
                                                                  Serialized_Type_Object_Dynamic_Allocation_Threshold   => 2048,
                                                                  Type_Object_Max_Deserialized_Length                   => -1,
                                                                  Deserialized_Type_Object_Dynamic_Allocation_Threshold => 4096,
                                                                  Contentfilter_Property_Max_Length                     => 256,
                                                                  Channel_Seq_Max_Length                                => 32,
                                                                  Channel_Filter_Expression_Max_Length                  => 256,
                                                                  Participant_Property_List_Max_Length                  => 32,
                                                                  Participant_Property_String_Max_Length                => 1024,
                                                                  Writer_Property_List_Max_Length                       => 32,
                                                                  Writer_Property_String_Max_Length                     => 1024,
                                                                  Reader_Property_List_Max_Length                       => 32,
                                                                  Reader_Property_String_Max_Length                     => 1024,
                                                                  Plugin_Info_Parameter_Max_Length                      => 256,
                                                                  Max_Endpoint_Groups                                   => 32,
                                                                  Max_Endpoint_Group_Cumulative_Characters              => 1024,
                                                                  Transport_Info_List_Max_Length                        => 12,
                                                                  Ignored_Entity_Replacement_Kind                       => NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT,
                                                                  Remote_Topic_Query_Allocation                         => (1, -1, -1),
                                                                  Remote_Topic_Query_Hash_Buckets                       => 1);

    EVENT_QOS_POLICY_NAME

    EVENT_QOS_POLICY_NAME                                 : constant DDS.String := To_DDS_String ("Event");

    Summary: Stringified human-readable name for DDS.EventQosPolicy

    DATABASE_QOS_POLICY_NAME

    DATABASE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Database");

    Summary: Stringified human-readable name for DDS.DatabaseQosPolicy

    RECEIVERPOOL_QOS_POLICY_NAME

    RECEIVERPOOL_QOS_POLICY_NAME : DDS.String := To_DDS_String ("ReceiverPool");

    Summary: Stringified human-readable name for DDS.ReceiverPoolQosPolicy

    ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT

    ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT : constant Long := -1;

    BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT

    BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT : constant BuiltinTopicReaderResourceLimits_T :=
                                                        (Initial_Samples                          => 64,
                                                         Max_Samples                              => -1,
                                                         Initial_Infos                            => 64,
                                                         Max_Infos                                => -1,
                                                         Initial_Outstanding_Reads                => 2,
                                                         Max_Outstanding_Reads                    => -1,
                                                         Max_Samples_Per_Read                     => 1024,
                                                         Disable_Fragmentation_Support            => False,
                                                         Max_Fragmented_Samples                   => 1024,
                                                         Initial_Fragmented_Samples               => 4,
                                                         Max_Fragmented_Samples_Per_Remote_Writer => 256,
                                                         Max_Fragments_Per_Sample                 => 512,
                                                         Dynamically_Allocate_Fragmented_Samples  => False);

    BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH

    BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH         : constant := 4;

    BuiltinTopicKey_T_INITIALIZER

    BuiltinTopicKey_T_INITIALIZER : constant BuiltinTopicKey_T :=
                                         (Value => (0, 0, 0, 0));

    PUBLISHMODE_QOS_POLICY_NAME

    PUBLISHMODE_QOS_POLICY_NAME   : constant DDS.String := To_DDS_String ("PublishMode");

    Summary: Stringified human-readable name for DDS.PublishModeQosPolicy

    SYNCHRONOUS_PUBLISH_MODE_QOS

    SYNCHRONOUS_PUBLISH_MODE_QOS  : constant PublishModeQosPolicyKind := 0;

    Summary: Indicates to send data synchronously.

    If DDS.DataWriterProtocolQosPolicy.push_on_write is DDS.BOOLEAN_TRUE, data is sent immediately in the context of FooDataWriter.write.

    As data is sent immediately in the context of the user thread, no flow control is applied.


    See also: DDS.DataWriterProtocolQosPolicy.push_on_write

    [default] for DDS.DataWriter

    ASYNCHRONOUS_PUBLISH_MODE_QOS

    ASYNCHRONOUS_PUBLISH_MODE_QOS : constant PublishModeQosPolicyKind := 1;

    Summary: Indicates to send data asynchronously.

    Configures the DDS.DataWriter to delegate the task of data transmission to a separate publishing thread. The FooDataWriter.write call does not send the data, but instead schedules the data to be sent later by its associated DDS.Publisher.

    Each DDS.Publisher uses its dedicated publishing thread (DDS.PublisherQos.asynchronous_publisher) to send data for all its asynchronous DataWriters. For each asynchronous DataWriter, the associated DDS.FlowController determines when the publishing thread is allowed to send the data.

    DDS.DataWriter.wait_for_asynchronous_publishing and DDS.Publisher.wait_for_asynchronous_publishing enable you to determine when the data has actually been sent.


    See also: DDS.FlowController
    See also: DDS.HistoryQosPolicy
    See also: DDS.DataWriter.wait_for_asynchronous_publishing
    See also: DDS.Publisher.wait_for_asynchronous_publishing
    See also: NDDS_Transport_Property_t.gather_send_buffer_count_max

    PUBLICATION_PRIORITY_UNDEFINED

    PUBLICATION_PRIORITY_UNDEFINED : constant Long := 0;

    Summary: Initializer value for DDS.PublishModeQosPolicy.priority and/or DDS.ChannelSettings_t.priority

    When assigned this value, the publication priority of the data writer, or channel of a multi-channel data writer, will be set to the lowest possible value. For muilti-channel data writers, if either the data writer or channel priority is NOT set to this value, then the publication priority of the entity will be set to the defined value.

    PUBLICATION_PRIORITY_AUTOMATIC

    PUBLICATION_PRIORITY_AUTOMATIC : constant Long := -1;

    Summary: Constant value for DDS.PublishModeQosPolicy.priority and/or DDS.ChannelSettings_t.priority

    When assigned this value, the publication priority of the data writer, or channel of a multi-channel data writer, will be set to the largest priority value of any sample currently queued for publication by the data writer or data writer channel.

    PUBLISH_MODE_QOS_POLICY_DEFAULT

    PUBLISH_MODE_QOS_POLICY_DEFAULT : constant PublishModeQosPolicy :=
                                           (Kind                      => SYNCHRONOUS_PUBLISH_MODE_QOS,
                                            Flow_Controller_Name      => (Data => DDS.NULL_STRING.Data),
                                            Priority                  => PUBLICATION_PRIORITY_UNDEFINED
                                           );

    DISCOVERYCONFIG_QOS_POLICY_NAME

    DISCOVERYCONFIG_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DiscoveryConfig");

    Summary: Stringified human-readable name for DDS.DiscoveryConfigQosPolicy

    DISCOVERYCONFIG_BUILTIN_SPDP

    DISCOVERYCONFIG_BUILTIN_SPDP  : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0001#;

    DISCOVERYCONFIG_BUILTIN_SEDP

    DISCOVERYCONFIG_BUILTIN_SEDP  : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0010#;

    DISCOVERYCONFIG_BUILTIN_SDP

    Summary: [default] Simple discovery plugin.

    DISCOVERYCONFIG_BUILTIN_EDS

    DISCOVERYCONFIG_BUILTIN_EDS   : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0100#;

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL     :
       constant  DiscoveryConfigBuiltinPluginKindMask := 16#EFFF#;

    Summary: All bits are set.


    See also: DDS.DiscoveryConfigBuiltinPluginKindMask

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE    :
       constant  DiscoveryConfigBuiltinPluginKindMask := 0;

    Summary: No bits are set.


    See also: DDS.DiscoveryConfigBuiltinPluginKindMask

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT :
       constant  DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_SDP;

    Summary: The default value of DDS.DiscoveryConfigQosPolicy.builtin_discovery_plugins.


    See also: DDS.DiscoveryConfigBuiltinPluginKindMask

    DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY

    DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 1;

    DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY

    DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 16#FFFF#;

    LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE

    LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE : constant RemoteParticipantPurgeKind := 0;

    Summary: [default] Maintain knowledge of the remote participant for as long as it maintains its liveliness contract.

    A participant will continue attempting communication with its peers, even if discovery communication with them is lost, as long as the remote participants maintain their liveliness. If both discovery communication and participant liveliness are lost, however, the local participant will remove all records of the remote participant and its contained endpoints, and no further data communication with them will occur until and unless they are rediscovered.

    The liveliness contract a participant promises to its peers -- its "liveliness lease duration" -- is specified in its DDS.DiscoveryConfigQosPolicy.participant_liveliness_lease_duration QoS field. It maintains that contract by writing data to those other participants with a writer that has a DDS.LivelinessQosPolicyKind of DDS.AUTOMATIC_LIVELINESS_QOS or DDS.MANUAL_BY_PARTICIPANT_LIVELINESS_QOS and by asserting itself (at the DDS.DiscoveryConfigQosPolicy.participant_liveliness_assert_period) over the Simple Discovery Protocol.

    NO_REMOTE_PARTICIPANT_PURGE

    NO_REMOTE_PARTICIPANT_PURGE   : constant RemoteParticipantPurgeKind := 1;

    Summary: Never "forget" a remote participant with which discovery communication has been lost.

    If a participant with this behavior loses discovery communication with a remote participant, it will nevertheless remember that remote participant and its endpoints and continue attempting to communicate with them indefinitely.

    This value has consequences for a participant's resource usage. If discovery communication with a remote participant is lost, but the same participant is later rediscovered, any relevant records that remain in the database will be reused. However, if it is not rediscovered, the records will continue to take up space in the database for as long as the local participant remains in existence.

    DISCOVERY_BUILTIN_READER_FRAGMENTATION_RESOURCE_LIMITS_DEFAULT

    DISCOVERY_BUILTIN_READER_FRAGMENTATION_RESOURCE_LIMITS_DEFAULT : constant DiscoveryBuiltinReaderFragmentationResourceLimits_T :=
                                                                          (Disable_Fragmentation_Support            => False,
                                                                           Max_Fragmented_Samples                   => 1024,
                                                                           Initial_Fragmented_Samples               => 4,
                                                                           Max_Fragmented_Samples_Per_Remote_Writer => 256,
                                                                           Max_Fragments_Per_Sample                 => 512,
                                                                           Dynamically_Allocate_Fragmented_Samples  => False);

    TYPESUPPORT_QOS_POLICY_NAME

    TYPESUPPORT_QOS_POLICY_NAME                                    : constant DDS.String := To_DDS_String ("TypeSupport");

    Summary: Stringified human-readable name for DDS.TypeSupportQosPolicy

    TYPESUPPORT_QOS_POLICY_DEFAULT

    TYPESUPPORT_QOS_POLICY_DEFAULT : constant TypeSupportQosPolicy :=
                                          (Plugin_Data      => System.Null_Address,
                                           Cdr_Padding_Kind => AUTO_CDR_PADDING);

    SEMAPHORE_BLOCKING_KIND

    SEMAPHORE_BLOCKING_KIND       : constant ThreadBlockingKind := 0;

    SPIN_BLOCKING_KIND

    SPIN_BLOCKING_KIND            : constant ThreadBlockingKind := 1;

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("AsynchronousPublisher");

    Summary: Stringified human-readable name for DDS.AsynchronousPublisherQosPolicy

    USEROBJECT_QOS_POLICY_NAME

    USEROBJECT_QOS_POLICY_NAME    : constant DDS.String := To_DDS_String ("UserObject");

    USER_OBJECT_QOS_POLICY_DEFAULT

    USER_OBJECT_QOS_POLICY_DEFAULT : constant UserObjectQosPolicy :=
                                          (others => (0, 0));

    EXCLUSIVEAREA_QOS_POLICY_NAME

    EXCLUSIVEAREA_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("ExclusiveArea");

    Summary: Stringified human-readable name for DDS.ExclusiveAreaQosPolicy.

    EXCLUSIVE_AREA_AUTO_LEVEL

    EXCLUSIVE_AREA_AUTO_LEVEL     : constant DDS.Long := -1;

    EXCLUSIVE_AREA_QOS_POLICY_DEFAULT

    EXCLUSIVE_AREA_QOS_POLICY_DEFAULT : constant ExclusiveAreaQosPolicy :=
                                             (Use_Shared_Exclusive_Area => False,
                                              Level                     => EXCLUSIVE_AREA_AUTO_LEVEL);

    TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME

    TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicQueryDispatch");
    TODO: Add Docs

    TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT

    TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT : constant TopicQueryDispatchQosPolicy :=
                                         (
                                          Enable                      => False,
                                          Publication_period          => (16#0000_0001#, 16#0000_0000#),
                                          Samples_Per_Period          => -1
                                         );
    TODO: Add Docs

    BATCH_QOS_POLICY_NAME

    BATCH_QOS_POLICY_NAME         : constant DDS.String := To_DDS_String ("Batch");

    Summary: Stringified human-readable name for DDS.BatchQosPolicy

    BATCH_QOS_POLICY_DEFAULT

    BATCH_QOS_POLICY_DEFAULT      : constant BatchQosPolicy :=
                                         (
                                          Enable                      => False,
                                          Max_Data_Bytes              => 1024,
                                          Max_Meta_Data_Bytes         => LENGTH_UNLIMITED,
                                          Max_Samples                 => LENGTH_UNLIMITED,
                                          Max_Flush_Delay             => (16#7FFF_FFFF#, 16#7FFF_FFFF#),
                                          Source_Timestamp_Resolution => (16#7FFF_FFFF#, 16#7FFF_FFFF#),
                                          Thread_Safe_Write           => True
                                         );

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeConsistencyEnforcement");

    Summary: Stringified human-readable name for DDS.TypeConsistencyEnforcementQosPolicy

    DISALLOW_TYPE_COERCION

    DISALLOW_TYPE_COERCION        : constant TypeConsistencyKind := 0;

    Summary: The DataWriter and the DataReader must support the same data type in order for them to communicate.

    This is the degree of type consistency enforcement required by the ef_url_dds_spec prior to the ef_url_xtypes_spec.

    ALLOW_TYPE_COERCION

    ALLOW_TYPE_COERCION           : constant TypeConsistencyKind := 1;

    Summary: The DataWriter and the DataReader need not support the same data type in order for them to communicate as long as the DataReader's type is assignable from the DataWriter's type.

    For example, the following two extensible types will be assignable to each other since MyDerivedType contains all the members of MyBaseType (member_1) plus some additional elements (member_2).

    struct MyBaseType {
         long member_1;
     };
     
     struct MyDerivedType: MyBaseType {
         long member_2;
     };
    

    Even if MyDerivedType was not explicitly inheriting from MyBaseType the types would still be assignable. For example:

    struct MyBaseType {
         long member_1;
     };
     
     struct MyDerivedType {
         long member_1;
         long member_2;
     };
    

    For additional information on type assignability refer to the ef_url_xtypes_spec.

    [default]

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT : constant TypeConsistencyEnforcementQosPolicy :=
                                                           (
                                                            Kind => ALLOW_TYPE_COERCION
                                                           );

    LOCATORFILTER_QOS_POLICY_NAME

    LOCATORFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LocatorFilter");

    Summary: Stringified human-readable name for DDS.LocatorFilterQosPolicy

    MULTICHANNEL_QOS_POLICY_NAME

    MULTICHANNEL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("MultiChannel");

    Summary: Stringified human-readable name for DDS.MultiChannelQosPolicy

    PROPERTY_QOS_POLICY_NAME

    PROPERTY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Property");

    Summary: Stringified human-readable name for DDS.PropertyQosPolicy.

    AVAILABILITY_QOS_POLICY_NAME

    AVAILABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Availability");

    Summary: Stringified human-readable name for DDS.AvailabilityQosPolicy

    ENTITYNAME_QOS_POLICY_NAME

    ENTITYNAME_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityName");

    Summary: Stringified human-readable name for DDS.EntityNameQosPolicy

    ENTITY_NAME_QOS_POLICY_DEFAULT

    ENTITY_NAME_QOS_POLICY_DEFAULT : constant EntityNameQosPolicy :=
                                          (Name      => (Data => DDS.NULL_STRING.Data),
                                           Role_Name => (Data => DDS.NULL_STRING.Data));

    LOGGING_QOS_POLICY_NAME

    LOGGING_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("Logging");

    Summary: Stringified human-readable name for DDS.LoggingQosPolicy

    PROFILE_QOS_POLICY_NAME

    PROFILE_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("Profile");

    Summary: Stringified human-readable name for DDS.ProfileQosPolicy

    AUTO_SAMPLE_IDENTITY

    AUTO_SAMPLE_IDENTITY           : constant SampleIdentity_T :=
                                          (Writer_Guid     => GUID_AUTO,
                                           Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);

    Summary: The AUTO sample identity

    Special DDS_AUTO_SAMPLE_IDENTITY value {DDS_GUID_AUTO, DDS_AUTO_SEQUENCE_NUMBER}

    UNKNOWN_SAMPLE_IDENTITY

    UNKNOWN_SAMPLE_IDENTITY        : constant SampleIdentity_T :=
                                          (Writer_Guid     => GUID_AUTO,
                                           Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);

    Summary: An invalid or unknown sample identity

    Special DDS_UNKNOWN_SAMPLE_IDENTITY value {DDS_GUID_UNKNOWN, DDS_SEQUENCE_NUMBER_UNKNOWN}

    COOKIE_DEFAULT

    COOKIE_DEFAULT : constant Cookie_T := (Value => Octet_Seq.DEFAULT_SEQUENCE);

    REDELIVERED_SAMPLE

    REDELIVERED_SAMPLE : constant SampleFlagBits := 0;

    Summary: Indicates that a sample has been redelivered by RTI Queuing Service.

    INTERMEDIATE_REPLY_SEQUENCE_SAMPLE

    INTERMEDIATE_REPLY_SEQUENCE_SAMPLE : constant SampleFlagBits := 1;

    Summary: Indicates that a response sample is not the last response sample for a given request. This bit is usually set by Connext Repliers sending multiple responses for a request.

    REPLICATE_SAMPLE

    REPLICATE_SAMPLE : constant SampleFlagBits := 2;

    Summary: Indicates if a sample must be broadcast by one RTI Queuing Service replica to other replicas.

    LAST_SHARED_READER_QUEUE_SAMPLE

    LAST_SHARED_READER_QUEUE_SAMPLE : constant SampleFlagBits := 3;

    Summary: Indicates that a sample is the last sample in a SharedReaderQueue for a QueueConsumer DataReader.

    WRITEPARAMS_DEFAULT

    WRITEPARAMS_DEFAULT : constant WriteParams_T
         := (Replace_Auto            => False,
             Identity                => AUTO_SAMPLE_IDENTITY,
             Related_Sample_Identity => UNKNOWN_SAMPLE_IDENTITY,
             Source_Timestamp        => (Sec => -1, Nanosec =>  0),
             Cookie                  => COOKIE_DEFAULT,
             Handle                  => Null_InstanceHandle_T,
             Priority                => 0,
             Flush_On_Write          => False,
             Flag                    => 0,
             Source_Guid             => GUID_AUTO,
             Related_Source_Guid     => GUID_UNKNOWN,
             Related_Reader_Guid     => GUID_UNKNOWN,
             Topic_Query_Guid        => GUID_UNKNOWN
            );

    Summary: Initializer for DDS_WriteParams_t

    BUILTIN_TOPIC_MAX_STRING_LENGTH

    BUILTIN_TOPIC_MAX_STRING_LENGTH : constant := 256;

    PARTICIPANT_TOPIC_NAME

    PARTICIPANT_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipant");

    Summary: Participant topic name

    Topic name of DDS.ParticipantBuiltinTopicDataDataReader


    See also: DDS.ParticipantBuiltinTopicData
    See also: DDS.ParticipantBuiltinTopicDataDataReader

    ParticipantBuiltinTopicData_TypeName

    ParticipantBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.dds_c.builtin_impl_h.DDS_PARTICIPANT_TYPE_NAME);

    TOPIC_TOPIC_NAME

    TOPIC_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSTopic");

    Summary: Topic topic name

    Topic name of DDS.TopicBuiltinTopicDataDataReader


    See also: DDS.TopicBuiltinTopicData
    See also: DDS.TopicBuiltinTopicDataDataReader

    TopicBuiltinTopicData_TypeName

    TopicBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.dds_c.builtin_impl_h.DDS_TOPIC_TYPE_NAME);

    PUBLICATION_TOPIC_NAME

    PUBLICATION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublication");

    Summary: Publication topic name

    Topic name of DDS.PublicationBuiltinTopicDataDataReader


    See also: DDS.PublicationBuiltinTopicData
    See also: DDS.PublicationBuiltinTopicDataDataReader

    PublicationBuiltinTopicData_TypeName

    PublicationBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.dds_c.builtin_impl_h.DDS_PUBLICATION_TYPE_NAME);

    SUBSCRIPTION_TOPIC_NAME

    SUBSCRIPTION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscription");

    Summary: Subscription topic name

    Topic name of DDS.SubscriptionBuiltinTopicDataDataReader


    See also: DDS.SubscriptionBuiltinTopicData
    See also: DDS.SubscriptionBuiltinTopicDataDataReader

    SubscriptionBuiltinTopicData_TypeName

    SubscriptionBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.dds_c.builtin_impl_h.DDS_SUBSCRIPTION_TYPE_NAME);

    InconsistentTopicStatus_INITIALIZER

    InconsistentTopicStatus_INITIALIZER : constant InconsistentTopicStatus :=
                                               (Total_Count        => 0,
                                                Total_Count_Change => 0);

    OfferedDeadlineMissedStatus_INITIALIZER

    OfferedDeadlineMissedStatus_INITIALIZER : constant OfferedDeadlineMissedStatus :=
                                                   (Total_Count          => 0,
                                                    Total_Count_Change   => 0,
                                                    Last_Instance_Handle => Null_InstanceHandle_T);

    LivelinessLostStatus_INITIALIZER

    LivelinessLostStatus_INITIALIZER : constant LivelinessLostStatus :=
                                            (Total_Count        => 0,
                                             Total_Count_Change => 0);

    PublicationMatchedStatus_INITIALIZER

    PublicationMatchedStatus_INITIALIZER : constant PublicationMatchedStatus :=
                                                (Total_Count              => 0,
                                                 Total_Count_Change       => 0,
                                                 Current_Count            => 0,
                                                 Current_Count_Peak       => 0,
                                                 Current_Count_Change     => 0,
                                                 Last_Subscription_Handle => Null_InstanceHandle_T);

    ReliableWriterCacheEventCount_INITIALIZER

    ReliableWriterCacheEventCount_INITIALIZER : constant ReliableWriterCacheEventCount :=
                                                     (Total_Count        => 0,
                                                      Total_Count_Change => 0);

    ReliableWriterCacheChangedStatus_INITIALIZER

    ReliableWriterCacheChangedStatus_INITIALIZER : constant ReliableWriterCacheChangedStatus :=
                                                        (Empty_Reliable_Writer_Cache          => ReliableWriterCacheEventCount_INITIALIZER,
                                                         Full_Reliable_Writer_Cache           => ReliableWriterCacheEventCount_INITIALIZER,
                                                         Low_Watermark_Reliable_Writer_Cache  => ReliableWriterCacheEventCount_INITIALIZER,
                                                         High_Watermark_Reliable_Writer_Cache => ReliableWriterCacheEventCount_INITIALIZER,
                                                         Unacknowledged_Sample_Count          => 0,
                                                         Unacknowledged_Sample_Count_Peak     => 0);

    ReliableReaderActivityChangedStatus_INITIALIZER

    ReliableReaderActivityChangedStatus_INITIALIZER : constant  ReliableReaderActivityChangedStatus :=
                                                           (Active_Count          => 0,
                                                            Inactive_Count        => 0,
                                                            Active_Count_Change   => 0,
                                                            Inactive_Count_Change => 0,
                                                            Last_Instance_Handle  => Null_InstanceHandle_T);

    RequestedDeadlineMissedStatus_INITIALIZER

    RequestedDeadlineMissedStatus_INITIALIZER : constant RequestedDeadlineMissedStatus :=
                                                     (Total_Count              => 0,
                                                      Total_Count_Change       => 0,
                                                      Last_Instance_Handle     => Null_InstanceHandle_T);

    LivelinessChangedStatus_INITIALIZER

    LivelinessChangedStatus_INITIALIZER : constant LivelinessChangedStatus :=
                                               (Alive_Count             => 0,
                                                Not_Alive_Count         => 0,
                                                Alive_Count_Change      => 0,
                                                Not_Alive_Count_Change  => 0,
                                                Last_Publication_Handle => Null_InstanceHandle_T);

    NOT_LOST

    NOT_LOST : constant SampleLostStatusKind := 0;

    Summary: The sample was not lost.

    This constant is an extension to the DDS standard.
    See also: DDS.ResourceLimitsQosPolicy

    LOST_BY_WRITER

    LOST_BY_WRITER : constant SampleLostStatusKind := 1;

    Summary: A DDS.DataWriter removed the sample before being received by the DDS.DataReader.

    This constant is an extension to the DDS standard.

    LOST_BY_INSTANCES_LIMIT

    LOST_BY_INSTANCES_LIMIT : constant SampleLostStatusKind := 2;

    Summary: A resource limit on the number of instances was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.ResourceLimitsQosPolicy

    LOST_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT

    LOST_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT : constant SampleLostStatusKind := 3;

    Summary: A resource limit on the number of remote writers for a single instance from which a DDS.DataReader may read was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_INCOMPLETE_COHERENT_SET

    LOST_BY_INCOMPLETE_COHERENT_SET : constant SampleLostStatusKind := 4;

    Summary: A sample is lost because it is part of a large coherent set.

    This constant is an extension to the DDS standard.

    LOST_BY_LARGE_COHERENT_SET

    LOST_BY_LARGE_COHERENT_SET : constant SampleLostStatusKind := 5;

    Summary: A sample is lost because it is part of a large coherent set.

    This constant is an extension to the DDS standard.

    LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT

    LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT : constant SampleLostStatusKind := 6;

    Summary: A resource limit on the number of samples from a given remote writer that a DDS.DataReader may store was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_VIRTUAL_WRITERS_LIMIT

    LOST_BY_VIRTUAL_WRITERS_LIMIT : constant SampleLostStatusKind := 7;

    LOST_BY_VIRTUAL_WRITERS_LIMIT: A resource limit on the number of virtual writers from which a DDS.DataReader may read was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT

    LOST_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT : constant SampleLostStatusKind := 8;

    LOST_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT: A resource limit on the number of remote writers per sample was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_AVAILABILITY_WAITING_TIME

    LOST_BY_AVAILABILITY_WAITING_TIME : constant SampleLostStatusKind := 9;

    LOST_BY_AVAILABILITY_WAITING_TIME: DDS.AvailabilityQosPolicy.max_data_availability_waiting_time expired.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT

    LOST_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT : constant SampleLostStatusKind := 10;

    LOST_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT: A resource limit on the number of samples published by a remote writer on behalf of a virtual writer that a DDS.DataReader may store was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    SampleLostStatus_INITIALIZER

    SampleLostStatus_INITIALIZER : constant SampleLostStatus :=
                                        (Total_Count        => 0,
                                         Total_Count_Change => 0,
                                         Last_Reason        => NOT_LOST);

    SampleRejectedStatus_INITIALIZER

    SampleRejectedStatus_INITIALIZER : constant SampleRejectedStatus :=
                                            (Total_Count          => 0,
                                             Total_Count_Change   => 0,
                                             Last_Reason          => NOT_REJECTED,
                                             Last_Instance_Handle => Null_InstanceHandle_T);

    SubscriptionMatchedStatus_INITIALIZER

    SubscriptionMatchedStatus_INITIALIZER : constant SubscriptionMatchedStatus :=
                                                 (Total_Count              => 0,
                                                  Total_Count_Change       => 0,
                                                  Current_Count            => 0,
                                                  Current_Count_Peak       => 0,
                                                  Current_Count_Change     => 0,
                                                  Last_Publication_Handle  => Null_InstanceHandle_T);

    DataReaderCacheStatus_INITIALIZER

    DataReaderCacheStatus_INITIALIZER : constant DataReaderCacheStatus :=
                                             (Sample_Count_Peak => 0,
                                              Sample_Count      => 0);

    DataReaderProtocolStatus_INITIALIZER

    DataReaderProtocolStatus_INITIALIZER : constant DataReaderProtocolStatus :=
                                                (Received_Sample_Count                  => 0,
                                                 Received_Sample_Count_Change           => 0,
                                                 Received_Sample_Bytes                  => 0,
                                                 Received_Sample_Bytes_Change           => 0,
                                                 Duplicate_Sample_Count                 => 0,
                                                 Duplicate_Sample_Count_Change          => 0,
                                                 Duplicate_Sample_Bytes                 => 0,
                                                 Duplicate_Sample_Bytes_Change          => 0,
                                                 Filtered_Sample_Count                  => 0,
                                                 Filtered_Sample_Count_Change           => 0,
                                                 Filtered_Sample_Bytes                  => 0,
                                                 Filtered_Sample_Bytes_Change           => 0,
                                                 Received_Heartbeat_Count               => 0,
                                                 Received_Heartbeat_Count_Change        => 0,
                                                 Received_Heartbeat_Bytes               => 0,
                                                 Received_Heartbeat_Bytes_Change        => 0,
                                                 Sent_Ack_Count                         => 0,
                                                 Sent_Ack_Count_Change                  => 0,
                                                 Sent_Ack_Bytes                         => 0,
                                                 Sent_Ack_Bytes_Change                  => 0,
                                                 Sent_Nack_Count                        => 0,
                                                 Sent_Nack_Count_Change                 => 0,
                                                 Sent_Nack_Bytes                        => 0,
                                                 Sent_Nack_Bytes_Change                 => 0,
                                                 Received_Gap_Count                     => 0,
                                                 Received_Gap_Count_Change              => 0,
                                                 Received_Gap_Bytes                     => 0,
                                                 Received_Gap_Bytes_Change              => 0,
                                                 Rejected_Sample_Count                  => 0,
                                                 Rejected_Sample_Count_Change           => 0,
                                                 First_Available_Sample_Sequence_Number => (-2147483648, 16#FFFF_FFFF#),
                                                 Last_Available_Sample_Sequence_Number  => (-2147483648, 16#FFFF_FFFF#),
                                                 Last_Committed_Sample_Sequence_Number  => (-2147483648, 16#FFFF_FFFF#),
                                                 Uncommitted_Sample_Count               => 0);

    READ_SAMPLE_STATE

    READ_SAMPLE_STATE : constant SampleStateKind     := 1;

    Summary: Sample has been read.

    NOT_READ_SAMPLE_STATE

    NOT_READ_SAMPLE_STATE : constant SampleStateKind := 2;

    Summary: Sample has not been read.

    ANY_SAMPLE_STATE

    ANY_SAMPLE_STATE  : constant SampleStateMask := 16#FFFF#;

    NEW_VIEW_STATE

    NEW_VIEW_STATE  : constant ViewStateKind     := 1;

    Summary: New instance. This latest generation of the instance has not previously been accessed.

    NOT_NEW_VIEW_STATE

    NOT_NEW_VIEW_STATE : constant ViewStateKind := 2;

    Summary: Not a new instance. This latest generation of the instance has previously been accessed.

    ANY_VIEW_STATE

    ANY_VIEW_STATE  : constant ViewStateMask := 16#FFFF#;

    Summary: Any view state DDS.NEW_VIEW_STATE | DDS.NOT_NEW_VIEW_STATE

    ALIVE_INSTANCE_STATE

    ALIVE_INSTANCE_STATE : constant InstanceStateKind                := 1;

    Summary: Instance is currently in existence.

    NOT_ALIVE_DISPOSED_INSTANCE_STATE

    NOT_ALIVE_DISPOSED_INSTANCE_STATE : constant InstanceStateKind   := 2;

    Summary: Not alive disposed instance. The instance has been disposed by a DataWriter.

    NOT_ALIVE_NO_WRITERS_INSTANCE_STATE

    NOT_ALIVE_NO_WRITERS_INSTANCE_STATE : constant InstanceStateKind := 4;

    Summary: Not alive no writers for instance. None of the DDS.DataWriter objects that are currently alive (according to the DDSLivelinessQosModule) are writing the instance.

    NOT_ALIVE_INSTANCE_STATE

    NOT_ALIVE_INSTANCE_STATE : constant InstanceStateMask := 6;

    ANY_INSTANCE_STATE

    ANY_INSTANCE_STATE  : constant InstanceStateMask := 16#FFFF#;

    SQLFILTER_NAME

    SQLFILTER_NAME  : constant DDS.String := To_DDS_String ("DDSSQL");

    Summary: <<ext>> The name of the built-in SQL filter that can be used with ContentFilteredTopics and MultiChannel DataWriters.


    See also: DDSQueryAndFilterSyntaxModule

    STRINGMATCHFILTER_NAME

    STRINGMATCHFILTER_NAME : constant DDS.String := To_DDS_String ("DDSSTRINGMATCH");

    Summary: <<ext>> The name of the built-in StringMatch filter that can be used with ContentFilteredTopics and MultiChannel DataWriters.

    The StringMatch Filter is a subset of the SQL filter; it only supports the MATCH relational operator on a single string field.


    See also: DDSQueryAndFilterSyntaxModule

    The StringMatch Filter is a subset of the SQL filter; it only supports the MATCH relational operator on a single string field.

    DEFAULT_FLOW_CONTROLLER_NAME

    DEFAULT_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_DEFAULT_FLOW_CONTROLLER_NAME");

    Summary: [default] Special value of DDS.PublishModeQosPolicy.flow_controller_name that refers to the built-in default flow controller.

    RTI Connext provides several built-in DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    By default, flow control is disabled. That is, the built-in DDS.DEFAULT_FLOW_CONTROLLER_NAME flow controller does not apply any flow control. Instead, it allows data to be sent asynchronously as soon as it is written by the DDS.DataWriter.

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = 0

    - DDS.FlowControllerProperty_t.token_bucket period = 1 second

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    RTI Connext provides several built-in DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    By default, flow control is disabled. That is, the built-in DDS.DEFAULT_FLOW_CONTROLLER_NAME flow controller does not apply any flow control. Instead, it allows data to be sent asynchronously as soon as it is written by the DDS.DataWriter.

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = 0

    - DDS.FlowControllerProperty_t.token_bucket period = 1 second

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    FIXED_RATE_FLOW_CONTROLLER_NAME

    FIXED_RATE_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_FIXED_RATE_FLOW_CONTROLLER_NAME");

    Summary: Special value of DDS.PublishModeQosPolicy.flow_controller_name that refers to the built-in fixed-rate flow controller.

    RTI Connext provides several builtin DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    The built-in DDS.FIXED_RATE_FLOW_CONTROLLER_NAME flow controller shapes the network traffic by allowing data to be sent only once every second. Any accumulated samples destined for the same destination are coalesced into as few network packets as possible.

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket period = 1 second

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    RTI Connext provides several builtin DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    The built-in DDS.FIXED_RATE_FLOW_CONTROLLER_NAME flow controller shapes the network traffic by allowing data to be sent only once every second. Any accumulated samples destined for the same destination are coalesced into as few network packets as possible.

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket period = 1 second

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    ON_DEMAND_FLOW_CONTROLLER_NAME

    ON_DEMAND_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_ON_DEMAND_FLOW_CONTROLLER_NAME");

    Summary: Special value of DDS.PublishModeQosPolicy.flow_controller_name that refers to the built-in on-demand flow controller.

    RTI Connext provides several builtin DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    The built-in DDS.ON_DEMAND_FLOW_CONTROLLER_NAME allows data to be sent only when the user calls DDS.FlowController.trigger_flow. With each trigger, all accumulated data since the previous trigger is sent (across all DDS.Publisher or DDS.DataWriter instances). In other words, the network traffic shape is fully controlled by the user. Any accumulated samples destined for the same destination are coalesced into as few network packets as possible.

    This external trigger source is ideal for users who want to implement some form of closed-loop flow control or who want to only put data on the wire every so many samples (e.g. with the number of samples based on NDDS_Transport_Property_t.gather_send_buffer_count_max).

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket period = DDS_DURATION_INFINITE

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.trigger_flow
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    RTI Connext provides several builtin DDS.FlowController for use with an asynchronous DDS.DataWriter. The user can choose to use the built-in flow controllers and optionally modify their properties or can create a custom flow controller.

    The built-in DDS.ON_DEMAND_FLOW_CONTROLLER_NAME allows data to be sent only when the user calls DDS.FlowController.trigger_flow. With each trigger, all accumulated data since the previous trigger is sent (across all DDS.Publisher or DDS.DataWriter instances). In other words, the network traffic shape is fully controlled by the user. Any accumulated samples destined for the same destination are coalesced into as few network packets as possible.

    This external trigger source is ideal for users who want to implement some form of closed-loop flow control or who want to only put data on the wire every so many samples (e.g. with the number of samples based on NDDS_Transport_Property_t.gather_send_buffer_count_max).

    Essentially, this is equivalent to a user-created DDS.FlowController with the following DDS.FlowControllerProperty_t settings:

    - DDS.FlowControllerProperty_t.scheduling_policy = DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY

    - DDS.FlowControllerProperty_t.token_bucket max_tokens = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_added_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket tokens_leaked_per_period = DDS.LENGTH_UNLIMITED

    - DDS.FlowControllerProperty_t.token_bucket period = DDS_DURATION_INFINITE

    - DDS.FlowControllerProperty_t.token_bucket bytes_per_token = DDS.LENGTH_UNLIMITED


    See also: DDS.Publisher.create_datawriter
    See also: DDS.DomainParticipant.lookup_flowcontroller
    See also: DDS.FlowController.trigger_flow
    See also: DDS.FlowController.set_property
    See also: DDS.PublishModeQosPolicy
    See also: DDS.AsynchronousPublisherQosPolicy

    RR_FLOW_CONTROLLER_SCHED_POLICY

    RR_FLOW_CONTROLLER_SCHED_POLICY : constant FlowControllerSchedulingPolicy := 0;

    Summary: Indicates to flow control in a round-robin fashion.

    Whenever tokens become available, the flow controller distributes the tokens uniformly across all of its (non-empty) destination queues. No destinations are prioritized. Instead, all destinations are treated equally and are serviced in a round-robin fashion.

    Whenever tokens become available, the flow controller distributes the tokens uniformly across all of its (non-empty) destination queues. No destinations are prioritized. Instead, all destinations are treated equally and are serviced in a round-robin fashion.

    EDF_FLOW_CONTROLLER_SCHED_POLICY

    EDF_FLOW_CONTROLLER_SCHED_POLICY : constant FlowControllerSchedulingPolicy := 1;

    Summary: Indicates to flow control in an earliest-deadline-first fashion.

    A sample's deadline is determined by the time it was written plus the latency budget of the DataWriter at the time of the write call (as specified in the DDS.LatencyBudgetQosPolicy). The relative priority of a flow controller's destination queue is determined by the earliest deadline across all samples it contains.

    When tokens become available, the DDS.FlowController distributes tokens to the destination queues in order of their deadline priority. In other words, the queue containing the sample with the earliest deadline is serviced first. The number of tokens granted equals the number of tokens required to send the first sample in the queue. Note that the priority of a queue may change as samples are sent (i.e. removed from the queue). If a sample must be sent to multiple destinations or two samples have an equal deadline value, the corresponding destination queues are serviced in a round-robin fashion.

    Hence, under the default DDS.LatencyBudgetQosPolicy.duration setting, an EDF_FLOW_CONTROLLER_SCHED_POLICY DDS.FlowController preserves the order in which the user calls FooDataWriter.write across the DataWriters associated with the flow controller.

    Since the DDS.LatencyBudgetQosPolicy is mutable, a sample written second may contain an earlier deadline than the sample written first if the DDS.LatencyBudgetQosPolicy.duration value is sufficiently decreased in between writing the two samples. In that case, if the first sample is not yet written (still in queue waiting for its turn), it inherits the priority corresponding to the (earlier) deadline from the second sample.

    In other words, the priority of a destination queue is always determined by the earliest deadline among all samples contained in the queue. This priority inheritance approach is required in order to both honor the updated DDS.LatencyBudgetQosPolicy.duration and adhere to the DDS.DataWriter in-order data delivery guarantee.

    [default] for DDS.DataWriter

    A sample's deadline is determined by the time it was written plus the latency budget of the DataWriter at the time of the write call (as specified in the DDS.LatencyBudgetQosPolicy). The relative priority of a flow controller's destination queue is determined by the earliest deadline across all samples it contains.

    When tokens become available, the DDS.FlowController distributes tokens to the destination queues in order of their deadline priority. In other words, the queue containing the sample with the earliest deadline is serviced first. The number of tokens granted equals the number of tokens required to send the first sample in the queue. Note that the priority of a queue may change as samples are sent (i.e. removed from the queue). If a sample must be sent to multiple destinations or two samples have an equal deadline value, the corresponding destination queues are serviced in a round-robin fashion.

    Hence, under the default DDS.LatencyBudgetQosPolicy.duration setting, an EDF_FLOW_CONTROLLER_SCHED_POLICY DDS.FlowController preserves the order in which the user calls FooDataWriter.write across the DataWriters associated with the flow controller.

    Since the DDS.LatencyBudgetQosPolicy is mutable, a sample written second may contain an earlier deadline than the sample written first if the DDS.LatencyBudgetQosPolicy.duration value is sufficiently decreased in between writing the two samples. In that case, if the first sample is not yet written (still in queue waiting for its turn), it inherits the priority corresponding to the (earlier) deadline from the second sample.

    In other words, the priority of a destination queue is always determined by the earliest deadline among all samples contained in the queue. This priority inheritance approach is required in order to both honor the updated DDS.LatencyBudgetQosPolicy.duration and adhere to the DDS.DataWriter in-order data delivery guarantee.

    [default] for DDS.DataWriter

    FlowControllerProperty_T_INITIALIZER

    FlowControllerProperty_T_INITIALIZER : constant FlowControllerProperty_T :=
                                                (Scheduling_Policy  => DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY,
                                                 Token_Bucket       => (-1, -1, 0, (1, 0), -1),
                                                 Is_Vendor_Specific => False);

    Summary: Initializer for new property instances.

    New DDS.FlowControllerProperty_t instances stored on the stack should be initialized with this value before they are passed to any procedure. This step ensures that the contained property values are properly initialized. This does not allocate memory.

    The simplest way to create a new property structure is to initialize it on the stack at the time of its creation:

    struct DDS_FlowControllerProperty_t myProperty = DDS_FlowControllerProperty_t_INITIALIZER;                    

    Note that the above assignment is not a substitute for calling DDS.DomainParticipant.get_default_flowcontroller_property.


    See also: DDS.DomainParticipant.get_default_flowcontroller_property

    OBJECT_NEW

    OBJECT_NEW       : constant ObjectSubState := 2#0000_0000_0000_0001#;

    OBJECT_MODIFIED

    OBJECT_MODIFIED  : constant ObjectSubState := 2#0000_0000_0000_0010#;

    OBJECT_READ

    OBJECT_READ      : constant ObjectSubState := 2#0000_0000_0000_0100#;

    OBJECT_DELETED

    OBJECT_DELETED   : constant ObjectSubState := 2#0000_0000_0000_1000#;

    OBJECT_CREATED

    OBJECT_CREATED   : constant ObjectSubState := 2#0000_0001_0000_0000#;

    OBJECT_CHANGED

    OBJECT_CHANGED   : constant ObjectSubState := 2#0000_0010_0000_0000#;

    OBJECT_WRITTEN

    OBJECT_WRITTEN   : constant ObjectSubState := 2#0000_0100_0000_0000#;

    OBJECT_DESTROYED

    OBJECT_DESTROYED : constant ObjectSubState := 2#0000_1000_0000_0000#;

    INFINITE_TIME_OUT

    INFINITE_TIME_OUT : constant TimeOutDuration  := -1;

    BadParameter

    BadParameter    : exception;

    NotFound

    NotFound        : exception;

    ReadOnlyMode

    ReadOnlyMode    : exception;

    WriteOnlyMode

    WriteOnlyMode   : exception;

    AlreadyClonedInWriteMode

    AlreadyClonedInWriteMode : exception;

    ExpiredTimeOut

    ExpiredTimeOut  : exception;

    UNLIMITED_RELATED_OBJECTS

    UNLIMITED_RELATED_OBJECTS : constant RelatedObjectDepth    := -1;

    Not_Implemented

    Not_Implemented : exception;

    Subprograms & Entries

    Length

    function Length 
    (Item: String) return Natural;

    WValue

    function WValue 
    (Item: Wwchars_Ptr) return Interfaces.C.char32_array;

    +

    function "+" 
    (Left: Wwchars_Ptr;
    Right: Interfaces.C.size_t) return Wwchars_Ptr;

    Peek

    function Peek 
    (From: Wwchars_Ptr) return Standard.Wide_Wide_Character;

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Long, Long_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Unsigned_Short, Unsigned_Short_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Unsigned_Long, Unsigned_Long_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Unsigned_Long_Long, Unsigned_Long_Long_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Enum, Enum_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Float, Float_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Double, Double_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Long_Double, Long_Double_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Char, Char_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Wchar, Wchar_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Octet, Octet_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Boolean, Boolean_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (String, String_Ptr);

    Deallocate

    procedure Deallocate is new Ada.Unchecked_Deallocation 
    (Wide_String, Wide_String_Ptr);

    Initialize

    procedure Initialize 
    (Self: in out Short);

    Finalize

    procedure Finalize 
    (Self: in out Short);

    Copy

    procedure Copy 
    (Dst: in out Short;
    Src: in Short);

    Initialize

    procedure Initialize 
    (Self: in out Long);

    Finalize

    procedure Finalize 
    (Self: in out Long);

    Copy

    procedure Copy 
    (Dst: in out Long;
    Src: in Long);

    Initialize

    procedure Initialize 
    (Self: in out Long_Long);

    Finalize

    procedure Finalize 
    (Self: in out Long_Long);

    Copy

    procedure Copy 
    (Dst: in out Long_Long;
    Src: in Long_Long);

    Initialize

    procedure Initialize 
    (Self: in out Unsigned_Short);

    Finalize

    procedure Finalize 
    (Self: in out Unsigned_Short);

    Copy

    procedure Copy 
    (Dst: in out Unsigned_Short;
    Src: in Unsigned_Short);

    Initialize

    procedure Initialize 
    (Self: in out Unsigned_Long);

    Finalize

    procedure Finalize 
    (Self: in out Unsigned_Long);

    Copy

    procedure Copy 
    (Dst: in out Unsigned_Long;
    Src: in Unsigned_Long);

    Initialize

    procedure Initialize 
    (Self: in out Unsigned_Long_Long);

    Finalize

    procedure Finalize 
    (Self: in out Unsigned_Long_Long);

    Copy

    procedure Copy 
    (Dst: in out Unsigned_Long_Long;
    Src: in Unsigned_Long_Long);

    Initialize

    procedure Initialize 
    (Self: in out Enum);

    Finalize

    procedure Finalize 
    (Self: in out Enum);

    Copy

    procedure Copy 
    (Dst: in out Enum;
    Src: in Enum);

    Initialize

    procedure Initialize 
    (Self: in out Float);

    Finalize

    procedure Finalize 
    (Self: in out Float);

    Copy

    procedure Copy 
    (Dst: in out Float;
    Src: in Float);

    Initialize

    procedure Initialize 
    (Self: in out Double);

    Finalize

    procedure Finalize 
    (Self: in out Double);

    Copy

    procedure Copy 
    (Dst: in out Double;
    Src: in Double);

    Initialize

    procedure Initialize 
    (Self: in out Long_Double);

    Finalize

    procedure Finalize 
    (Self: in out Long_Double);

    Copy

    procedure Copy 
    (Dst: in out Long_Double;
    Src: in Long_Double);

    Initialize

    procedure Initialize 
    (Self: in out Char);

    Finalize

    procedure Finalize 
    (Self: in out Char);

    Copy

    procedure Copy 
    (Dst: in out Char;
    Src: in Char);

    Initialize

    procedure Initialize 
    (Self: in out Wchar);

    Finalize

    procedure Finalize 
    (Self: in out Wchar);

    Copy

    procedure Copy 
    (Dst: in out Wchar;
    Src: in Wchar);

    Initialize

    procedure Initialize 
    (Self: in out Octet);

    Finalize

    procedure Finalize 
    (Self: in out Octet);

    Copy

    procedure Copy 
    (Dst: in out Octet;
    Src: in Octet);

    Octets_Of

    function Octets_Of 
    (Item: Octet_Array) return Octets is (Octets'(Length => Item'Length, Value => Item (Item'First)'Address));

    Octets_Of

    function Octets_Of 
    (Item: Octet_Seq.Sequence) return Octets is (Octets'(Length => Item.Length, Value => Item.Contiguous_Buffer.all'Address));

    Initialize

    procedure Initialize 
    (Self: in out Octets);

    Finalize

    procedure Finalize 
    (Self: in out Octets);

    Copy

    procedure Copy 
    (Dst: in out Octets;
    Src: in Octets);

    Initialize

    procedure Initialize 
    (Self: in out Boolean);

    Finalize

    procedure Finalize 
    (Self: in out Boolean);

    Copy

    procedure Copy 
    (Dst: in out Boolean;
    Src: in Boolean);

    To_DDS_String

    function To_DDS_String 
    (Source: Standard.String) return DDS.String is (Data => RTIDDS.To_Chars_Ptr (Source));

    To_Standard_String

    function To_Standard_String 
    (Source: DDS.String) return Standard.String;

    Copy

    procedure Copy 
    (Dst: in out DDS.String;
    Src: in Standard.String);

    Copy

    procedure Copy 
    (Dst: in out Standard.String;
    Src: in DDS.String);

    =

    function "=" 
    (L, R: DDS.String) return Boolean;

    Initialize

    procedure Initialize 
    (Self: in out DDS.String);

    Finalize

    procedure Finalize 
    (Self: in out DDS.String);

    Copy

    procedure Copy 
    (Dst: in out DDS.String;
    Src: in DDS.String);

    To_DDS_KeyedString

    function To_DDS_KeyedString 
    (Key: Standard.String;
    Source: Standard.String) return DDS.KeyedString;

    To_Standard_String

    function To_Standard_String 
    (Source: DDS.KeyedString) return Standard.String;

    Get_Key_From_KeyedString

    function Get_Key_From_KeyedString 
    (Source: DDS.KeyedString) return Standard.String;

    =

    function "=" 
    (L, R: DDS.KeyedString) return Boolean;

    Initialize

    procedure Initialize 
    (Self: in out DDS.KeyedString);

    Finalize

    procedure Finalize 
    (Self: in out DDS.KeyedString);

    Copy

    procedure Copy 
    (Dst: in out DDS.KeyedString;
    Src: in DDS.KeyedString);

    KeyedString_Of

    function KeyedString_Of 
    (Value: DDS.String;
    Key: DDS.String) return KeyedString;

    KeyedString_Of

    function KeyedString_Of 
    (Key: DDS.String) return KeyedString;

    KeyedString_Of

    function KeyedString_Of 
    (Value: Standard.String;
    Key: Standard.String) return KeyedString;

    KeyedString_Of

    function KeyedString_Of 
    (Key: Standard.String) return KeyedString;
    NOTE that the above functions does not do any copying of data They are just generation references.

    Initialize

    procedure Initialize 
    (Self: in out DDS.KeyedOctets);

    Finalize

    procedure Finalize 
    (Self: in out DDS.KeyedOctets);

    Copy

    procedure Copy 
    (Dst: in out DDS.KeyedOctets;
    Src: in DDS.KeyedOctets);

    KeyedOctets_Of

    function KeyedOctets_Of 
    (Key: String;
    Value: Octets := Null_Octets) return KeyedOctets;

    KeyedOctets_Of

    function KeyedOctets_Of 
    (Key: String;
    Value: Octet_Array) return KeyedOctets;

    KeyedOctets_Of

    function KeyedOctets_Of 
    (Key: String;
    Value: Octet_Seq.Sequence) return KeyedOctets;

    KeyedOctets_Of_Generic (generic)

    generic type Data_Type is private;function KeyedOctets_Of_Generic 
    (Key: String;
    Value: Data_Type) return KeyedOctets;

    To_DDS_Wide_String

    function To_DDS_Wide_String 
    (Source: Standard.Wide_Wide_String) return DDS.Wide_String;

    To_Standard_Wide_Wide_String

    function To_Standard_Wide_Wide_String 
    (Source: DDS.Wide_String) return Standard.Wide_Wide_String;

    Copy

    procedure Copy 
    (Dst: in out DDS.Wide_String;
    Src: in Standard.Wide_Wide_String);

    Copy

    procedure Copy 
    (Dst: in out Standard.Wide_Wide_String;
    Src: in DDS.Wide_String);

    =

    function "=" 
    (L, R: DDS.Wide_String) return Boolean;

    Initialize

    procedure Initialize 
    (Self: in out DDS.Wide_String);

    Finalize

    procedure Finalize 
    (Self: in out DDS.Wide_String);

    Copy

    procedure Copy 
    (Dst: in out DDS.Wide_String;
    Src: in DDS.Wide_String);

    <

    function "<" 
    (L: Time_T;
    R: Time_T) return Boolean;

    >

    function ">" 
    (L: Time_T;
    R: Time_T) return Boolean;

    <=

    function "<=" 
    (L: Time_T;
    R: Time_T) return Boolean;

    >=

    function ">=" 
    (L: Time_T;
    R: Time_T) return Boolean;

    +

    function "+" 
    (L: Time_T;
    R: Time_T) return Time_T;

    Time_Is_Zero

    function Time_Is_Zero 
    (T: Time_T) return Boolean;

    Summary: Check if time is zero

    Returns: DDS.BOOLEAN_TRUE if the given time is equal to DDS_TIME_ZERO or DDS.BOOLEAN_FALSE otherwise.

    Time_Is_Invalid

    function Time_Is_Invalid 
    (T: Time_T) return Boolean;

    Returns: DDS.BOOLEAN_TRUE if the given time is not valid (i.e. is negative)

    To_Time

    function To_Time 
    (T: Time_T) return Ada.Calendar.Time;

    To_Time

    function To_Time 
    (T: Time_T) return Ada.Real_Time.Time;

    To_Time_T

    function To_Time_T 
    (T: Ada.Calendar.Time) return Time_T;

    To_Time_T

    function To_Time_T 
    (T: Ada.Real_Time.Time) return Time_T;
    ------------------------------------------------- Duration_t -------------------------------------------------

    Duration_Is_Zero

    function Duration_Is_Zero 
    (D: Duration_T) return Boolean;

    Returns: DDS.BOOLEAN_TRUE if the given duration is of zero length.

    Duration_Is_Infinite

    function Duration_Is_Infinite 
    (D: Duration_T) return Boolean;

    Returns: DDS.BOOLEAN_TRUE if the given duration is of infinite length.

    Duration_Is_Auto

    function Duration_Is_Auto 
    (D: Duration_T) return Boolean;

    Returns: DDS.BOOLEAN_TRUE if the given duration has auto value.

    To_Duration

    function To_Duration 
    (D: Duration_T) return Standard.Duration;

    To_Duration_T

    function To_Duration_T 
    (D: Standard.Duration) return Duration_T;

    Initialize

    procedure Initialize 
    (Self: in out InstanceHandle_T);

    Finalize

    procedure Finalize 
    (Self: in out InstanceHandle_T);

    Copy

    procedure Copy 
    (Dst: in out InstanceHandle_T;
    Src: in InstanceHandle_T);
    package InstanceHandle_Seq is new Ada.Containers.Vectors (Positive, InstanceHandle_T);

    InstanceHandle_Equals

    function InstanceHandle_Equals 
    (Self: not null access InstanceHandle_T;
    Other: not null access InstanceHandle_T) return Boolean;

    Summary: Compares this instance handle with another handle for equality.

    other: <<in>> The other handle to be compared with this handle. Cannot be ull_value.

    Returns: DDS.BOOLEAN_TRUE if the two handles have equal values, or DDS.BOOLEAN_FALSE otherwise.


    See also: DDS_InstanceHandle_is_nil

    InstanceHandle_Is_Nil

    function InstanceHandle_Is_Nil 
    (Self: not null access InstanceHandle_T) return Boolean;

    Summary: Compare this handle to DDS_HANDLE_NIL

    Returns: DDS.BOOLEAN_TRUE if the given instance handle is equal to DDS_HANDLE_NIL or DDS.BOOLEAN_FALSE otherwise.


    See also: DDS_InstanceHandle_equals

    Guid_Equals

    function Guid_Equals 
    (Self: not null Guid_T_Access;
    Other: not null Guid_T_Access) return Boolean;

    Summary: Compares this GUID with another GUID for equality.

    other: <<in>> The other GUID to be compared with this GUID. Cannot be ull_value.

    Returns: DDS.BOOLEAN_TRUE if the two GUIDs have equal values, or DDS.BOOLEAN_FALSE otherwise.

    Guid_Compare

    function Guid_Compare 
    (Self: not null Guid_T_Access;
    Other: not null Guid_T_Access) return Boolean;

    Summary: Compares two GUIDs

    self: <<in>> GUID to compare. Cannot be ull_value.

    other: <<in>> GUID to compare. Cannot be ull_value.

    Returns: If the two GUIDs are equal, the function returns 0. If self is greater than other the function returns a positive number; otherwise, it returns a negative number.

    Guid_Copy

    procedure Guid_Copy 
    (Self: Guid_T_Access;
    Other: Guid_T_Access);

    Summary: Copies another GUID into this GUID.

    other: <<in>> The other GUID to be copied.

    Guid_Print

    procedure Guid_Print 
    (Self: Guid_T_Access;
    Desc: String;
    Indent: Unsigned_Long);

    Guid_Zero

    procedure Guid_Zero 
    (Self: Guid_T_Access);

    -

    function "-" 
    (L, R: SequenceNumber_T) return SequenceNumber_T;

    +

    function "+" 
    (L, R: SequenceNumber_T) return SequenceNumber_T;

    >

    function ">" 
    (L, R: SequenceNumber_T) return Boolean;

    <

    function "<" 
    (L, R: SequenceNumber_T) return Boolean;

    Increment

    procedure Increment 
    (Item: in out SequenceNumber_T);

    Decrement

    procedure Decrement 
    (Item: in out SequenceNumber_T);

    Image

    function Image 
    (Item: SequenceNumber_T) return Standard.String;

    Ret_Code_To_Exception

    procedure Ret_Code_To_Exception 
    (Code: ReturnCode_T;
    Message: Standard.String := "");

    +

    function "+" 
    (Left, Right: StatusKind) return StatusKind renames "or";

    ThreadSettings_T_Get_Default

    procedure ThreadSettings_T_Get_Default 
    (Self: not null ThreadSettings_T_Access);

    ThreadSettings_T_Is_Equal

    function ThreadSettings_T_Is_Equal 
    (Self: not null ThreadSettings_T_Access;
    Other: not null ThreadSettings_T_Access) return Boolean;

    Initialize

    procedure Initialize 
    (Self: in out QosPolicyCount);

    Finalize

    procedure Finalize 
    (Self: in out QosPolicyCount);

    Copy

    procedure Copy 
    (Dst: in out QosPolicyCount;
    Src: in QosPolicyCount);

    +

    function "+" 
    (Left, Right: aliased AllocationSettings_T) return AllocationSettings_T;

    Initialize

    procedure Initialize 
    (Self: in out TransportUnicastSettings_T);

    Finalize

    procedure Finalize 
    (Self: in out TransportUnicastSettings_T);

    Initialize

    procedure Initialize 
    (Self: in out TransportMulticastSettings_T);

    Finalize

    procedure Finalize 
    (Self: in out TransportMulticastSettings_T);

    Initialize

    procedure Initialize 
    (Self: in out TransportMulticastMapping_T);

    Finalize

    procedure Finalize 
    (Self: in out TransportMulticastMapping_T);

    Initialize

    procedure Initialize 
    (Self: in out EncapsulationId_T);

    Finalize

    procedure Finalize 
    (Self: in out EncapsulationId_T);

    Copy

    procedure Copy 
    (Dst: in out EncapsulationId_T;
    Src: in EncapsulationId_T);

    Initialize

    procedure Initialize 
    (Self: in out TransportEncapsulationSettings_T);

    Finalize

    procedure Finalize 
    (Self: in out TransportEncapsulationSettings_T);

    Initialize

    procedure Initialize 
    (Self: in out Discovery_ParticipantInformation);

    Finalize

    procedure Finalize 
    (Self: in out Discovery_ParticipantInformation);

    Initialize

    procedure Initialize 
    (Self: in out Discovery_EndpointInformation);

    Finalize

    procedure Finalize 
    (Self: in out Discovery_EndpointInformation);

    Initialize

    procedure Initialize 
    (Self: in out Locator_T);

    Finalize

    procedure Finalize 
    (Self: in out Locator_T);

    Copy

    procedure Copy 
    (Dst: in out Locator_T;
    Src: in Locator_T);

    BuiltinTopicKey_Equals

    function BuiltinTopicKey_Equals 
    (A: in BuiltinTopicKey_T_Access;
    B: in BuiltinTopicKey_T_Access) return DDS.Boolean;

    Initialize

    procedure Initialize 
    (Self: in out LocatorFilter_T);

    Finalize

    procedure Finalize 
    (Self: in out LocatorFilter_T);

    Copy

    procedure Copy 
    (Dst: in out LocatorFilter_T;
    Src: in LocatorFilter_T);

    Initialize

    procedure Initialize 
    (Self: in out ChannelSettings_T);

    Finalize

    procedure Finalize 
    (Self: in out ChannelSettings_T);

    Copy

    procedure Copy 
    (Dst: in out ChannelSettings_T;
    Src: in ChannelSettings_T);

    Initialize

    procedure Initialize 
    (Self: in out Property_T);

    Finalize

    procedure Finalize 
    (Self: in out Property_T);

    Copy

    procedure Copy 
    (Dst: in out Property_T;
    Src: in Property_T);

    Contains

    function Contains 
    (P: PropertyQosPolicy;
    Name: Standard.String) return Boolean;

    Contains

    function Contains 
    (P: PropertyQosPolicy;
    Name: DDS.String) return Boolean;

    Length

    function Length 
    (P: PropertyQosPolicy) return Natural;

    Append

    procedure Append 
    (P: in out PropertyQosPolicy;
    Name: Standard.String;
    Value: Standard.String;
    Propagate: Boolean := False);

    Append

    procedure Append 
    (P: in out PropertyQosPolicy;
    Name: DDS.String;
    Value: DDS.String;
    Propagate: Boolean := False);

    Delete

    procedure Delete 
    (P: in out PropertyQosPolicy;
    Name: Standard.String);

    Delete

    procedure Delete 
    (P: in out PropertyQosPolicy;
    Name: DDS.String);

    Get

    function Get 
    (P: PropertyQosPolicy;
    Name: DDS.String) return DDS.String;

    Initialize

    procedure Initialize 
    (Self: in out EndpointGroup_T);

    Finalize

    procedure Finalize 
    (Self: in out EndpointGroup_T);

    Copy

    procedure Copy 
    (Dst: in out EndpointGroup_T;
    Src: in EndpointGroup_T);

    =

    function "=" 
    (Left, Right: Cookie_T) return Standard.Boolean;
    COOKIE_DEFAULT : constant Cookie_T := ( Value => Octet_Seq.DEFAULT_SEQUENCE; );

    Initialize

    procedure Initialize 
    (Self: in out Cookie_T);

    Finalize

    procedure Finalize 
    (Self: in out Cookie_T);

    Copy

    procedure Copy 
    (Dst: in out Cookie_T;
    Src: in Cookie_T);

    WriteParams_Equals

    function WriteParams_Equals 
    (Self: in WriteParams_T_Access;
    Other: in WriteParams_T_Access) return DDS.Boolean;

    Initialize

    procedure Initialize 
    (This: in out TransportInfo_T);

    Finalize

    procedure Finalize 
    (This: in out TransportInfo_T);

    Copy

    procedure Copy 
    (Dst: in out TransportInfo_T;
    Src: in TransportInfo_T);

    Print

    procedure Print 
    (UserData: ParticipantBuiltinTopicData_Access;
    Desc: DDS.String;
    Indent: Long) with Convention => C, Import => True, Link_Name => "DDS_ParticipantBuiltinTopicDataPlugin_print";

    ParticipantBuiltinTopicData_Get_TypeCode

    function ParticipantBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;

    Initialize

    procedure Initialize 
    (This: in out ParticipantBuiltinTopicData);

    Finalize

    procedure Finalize 
    (This: in out ParticipantBuiltinTopicData);

    TopicBuiltinTopicData_Get_TypeCode

    function TopicBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;

    Initialize

    procedure Initialize 
    (This: in out TopicBuiltinTopicData);

    Finalize

    procedure Finalize 
    (This: in out TopicBuiltinTopicData);

    Copy

    procedure Copy 
    (Dst: in out TopicBuiltinTopicData;
    Src: in TopicBuiltinTopicData);

    PublicationBuiltinTopicData_Get_TypeCode

    function PublicationBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;

    Initialize

    procedure Initialize 
    (This: in out PublicationBuiltinTopicData);

    Finalize

    procedure Finalize 
    (This: in out PublicationBuiltinTopicData);

    SubscriptionBuiltinTopicData_Get_TypeCode

    function SubscriptionBuiltinTopicData_Get_TypeCode return Standard.DDS.TypeCode_Access;

    Initialize

    procedure Initialize 
    (This: in out SubscriptionBuiltinTopicData);

    Finalize

    procedure Finalize 
    (This: in out SubscriptionBuiltinTopicData);

    Initialize

    procedure Initialize 
    (Self: in out TopicQos);

    Summary: Initializer for new QoS instances.

    New DDS.TopicQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.Topic.get_qos or DDS.DomainParticipant.get_default_topic_qos; one of those should be called subsequently to setting the QoS of any new or existing entity. DDS.TopicQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_TopicQos *myQos = malloc(sizeof(struct DDS_TopicQos)); 
     DDS_TopicQos_initialize(myQos); 
     DDS_DomainParticipantFactory_get_default_topic_qos(myFactory, myQos);
     DDS_Topic_set_qos(myTopic, myQos);
     DDS_TopicQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.TopicQos.INITIALIZER
    See also: DDS.DomainParticipant.get_default_topic_qos
    See also: DDS.TopicQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out TopicQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.TopicQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.TopicQos.INITIALIZER
    See also: DDS.TopicQos.initialize

    Copy

    procedure Copy 
    (Target: in out TopicQos;
    Source: in TopicQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.TopicQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>>. QoS to be copied from.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.TopicQos.INITIALIZER
    See also: DDS.TopicQos.initialize
    See also: DDS.TopicQos.finalize

    Initialize

    procedure Initialize 
    (Self: in out DataWriterQos);

    Summary: Initializer for new QoS instances.

    New DDS.DataWriterQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.DataWriter.get_qos or DDS.Publisher.get_default_datawriter_qos; one of those should be called subsequently to setting the QoS of any new or existing entity. DDS.DataWriterQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_DataWriterQos *myQos = malloc(sizeof(struct DDS_DataWriterQos)); 
     DDS_DataWriterQos_initialize(myQos); 
     DDS_Publisher_get_default_datawriter_qos(myFactory, myQos);
     DDS_DataWriter_set_qos(myDataWriter, myQos);
     DDS_DataWriterQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.Publisher.get_default_datawriter_qos
    See also: DDS.DataWriterQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out DataWriterQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.DataWriterQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DataWriterQos.INITIALIZER
    See also: DDS.DataWriterQos.initialize

    Copy

    procedure Copy 
    (Target: out DataWriterQos;
    Source: in DataWriterQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.DataWriterQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>> The DDS.DataWriterQos to copy from.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DataWriterQos.INITIALIZER
    See also: DDS.DataWriterQos.initialize
    See also: DDS.DataWriterQos.finalize

    Initialize

    procedure Initialize 
    (Self: in out PublisherQos);

    Summary: Initializer for new QoS instances.

    New DDS.PublisherQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.Publisher.get_qos or DDS.DomainParticipant.get_default_publisher_qos; one of those should be called subsequently to setting the QoS of any new or existing entity. DDS.PublisherQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_PublisherQos *myQos = malloc(sizeof(struct DDS_PublisherQos)); 
     DDS_PublisherQos_initialize(myQos); 
     DDS_Publisher_get_default_datawriter_qos(myFactory, myQos);
     DDS_Publisher_set_qos(myPublisher, myQos);
     DDS_PublisherQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipant.get_default_publisher_qos
    See also: DDS.PublisherQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out PublisherQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.PublisherQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.PublisherQos.INITIALIZER
    See also: DDS.PublisherQos.initialize

    Copy

    procedure Copy 
    (Target: out PublisherQos;
    Source: in PublisherQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.PublisherQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>> The DDS.PublisherQos to copy from.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.PublisherQos.INITIALIZER
    See also: DDS.PublisherQos.initialize
    See also: DDS.PublisherQos.finalize

    Initialize

    procedure Initialize 
    (Self: in out SampleInfo);

    Finalize

    procedure Finalize 
    (Self: in out SampleInfo);

    Copy

    procedure Copy 
    (Dst: in out SampleInfo;
    Src: in SampleInfo);

    Initialize

    procedure Initialize 
    (Self: in out DataReaderQoS);

    Summary: Initializer for new QoS instances.

    New DDS.DataReaderQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.DataReader.get_qos or DDS.DomainParticipant.get_default_datareader_qos; one of those should be called subsequently to setting the QoS of any new or existing entity. DDS.DataReaderQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_DataReaderQos *myQos = malloc(sizeof(struct DDS_DataReaderQos)); 
     DDS_DataReaderQos_initialize(myQos); 
     DDS_DomainParticipantFactory_get_default_datareader_qos(myFactory, myQos);
     DDS_DataReaderQos_set_qos(myDataReader, myQos);
     DDS_DataReaderQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL


    See also: DDS.DataReaderQos.INITIALIZER
    See also: DDS.DomainParticipant.get_default_datareader_qos
    See also: DDS.DataReaderQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out DataReaderQoS);

    Summary: Free any dynamic memory allocated by the policies in this DDS.DataReaderQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Copy

    procedure Copy 
    (Target: out DataReaderQoS;
    Source: in DataReaderQoS);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.DataReaderQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>>. Status to be copied from.

    Initialize

    procedure Initialize 
    (Self: in out SubscriberQos);

    Summary: Initializer for new QoS instances.

    New DDS.SubscriberQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.Subscriber.get_qos or DDS.DomainParticipant.get_default_subscriber_qos; one of those should be called subsequently to setting the QoS of any new or existing entity. DDS.SubscriberQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_SubscriberQos *myQos = malloc(sizeof(struct DDS_SubscriberQos)); 
     DDS_SubscriberQos_initialize(myQos); 
     DDS_DomainParticipantFactory_get_default_subscriber_qos(myFactory, myQos);
     DDS_Subscriber_set_qos(mySubscriber, myQos);
     DDS_SubscriberQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.SubscriberQos.INITIALIZER
    See also: DDS.DomainParticipant.get_default_subscriber_qos
    See also: DDS.SubscriberQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out SubscriberQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.SubscriberQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes

    Copy

    procedure Copy 
    (Target: out SubscriberQos;
    Source: in SubscriberQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.SubscriberQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>> The DDS.PublisherQos to copy from.

    Raises: One of the DDSReturnTypesModules_std_retcodes

    Initialize

    procedure Initialize 
    (Self: in out DomainParticipantQos);

    Summary: Initializer for new QoS instances.

    New DDS.DomainParticipantQos instances on heap should be initialized with this procedure before they are passed to any procedures. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.DomainParticipant.get_qos or DDS.DomainParticipantFactory.get_default_participant_qos; one of those procedures should be called subsequently to setting the QoS of any new or existing entity. DDS.DomainParticipantQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_DomainParticipantQos *myQos = malloc(sizeof(struct DDS_DomainParticipantQos)); 
     DDS_DomainParticipantQos_initialize(myQos); 
     DDS_DomainParticipantFactory_get_default_participant_qos(myFactory, myQos);
     DDS_DomainParticipant_set_qos(myParticipant, myQos);
     DDS_DomainParticipantQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantFactory.get_default_participant_qos
    See also: DDS.DomainParticipantQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out DomainParticipantQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.DomainParticipantQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to finalize a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantQos.INITIALIZER
    See also: DDS.DomainParticipantQos.initialize

    Copy

    procedure Copy 
    (Target: out DomainParticipantQos;
    Source: in DomainParticipantQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.DomainParticipantQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>>. QoS to be copied from.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantQos.INITIALIZER
    See also: DDS.DomainParticipantQos.initialize
    See also: DDS.DomainParticipantQos.finalize

    Copy

    procedure Copy 
    (Target: out DomainParticipantFactoryQos;
    Source: in DomainParticipantFactoryQos);

    Summary: Copy the contents of the given QoS into this QoS.

    DDS.DomainParticipantFactoryQos instances can use dynamic memory because of the sequences contained in some QoS policies. A shallow copy by assignment is therefore unsafe. This procedure performs a deep-copy, allocating memory if necessary.

    self: <<in>> Cannot be NULL

    source: <<in>>. QoS to be copied from.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantFactoryQos.INITIALIZER
    See also: DDS.DomainParticipantFactoryQos.initialize
    See also: DDS.DomainParticipantFactoryQos.finalize

    Initialize

    procedure Initialize 
    (Self: in out DomainParticipantFactoryQos);

    Summary: Initializer for new QoS instances.

    New DDS.DomainParticipantFactoryQos instances on heap should be initialized with this procedure before they are passed to any procedure. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This procedure does not allocate memory.

    Calling this procedure is not a substitute for calling DDS.DomainParticipantFactory.get_qos; that procedure should be called subsequently to setting the QoS of an existing factory. DDS.DomainParticipantFactoryQos.finalize should be called to free the contained QoS policies that use dynamic memory:

    DDS_DomainParticipantFactoryQos *myQos = malloc(sizeof(struct DDS_DomainParticipantFactoryQos)); 
     DDS_DomainParticipantQos_initialize(myQos); 
     DDS_DomainParticipantFactory_get_qos(myFactory, myQos);
     DDS_DomainParticipantFactory_set_qos(myFactory, myQos);
     DDS_DomainParticipantFactoryQos_finalize(myQos);
     free(myQos);                    

    self: <<in>> Cannot be NULL

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantFactory.get_qos
    See also: DDS.DomainParticipantFactoryQos.finalize

    Finalize

    procedure Finalize 
    (Self: in out DomainParticipantFactoryQos);

    Summary: Free any dynamic memory allocated by the policies in this DDS.DomainParticipantFactoryQos.

    Some QoS policies may use dynamic memory (regardless of whether the QoS itself is in dynamic memory). This procedure frees that memory but otherwise leaves this QoS unchanged. It should be called on all instances before they are freed (or, in the case of stack-based instances, before they go out of scope).

    This procedure does not leave this object in an invalid state. It is permissable to clear a QoS and then subsequently allocate new dynamic memory in one or more of its QoS policies.

    Note that if this QoS instance is stored in heap memory, calling this procedure will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this procedure.

    Raises: One of the DDSReturnTypesModules_std_retcodes


    See also: DDS.DomainParticipantFactoryQos.INITIALIZER
    See also: DDS.DomainParticipantFactoryQos.initialize

    Copy

    procedure Copy 
    (C_Out: not null access FlowControllerProperty_T;
    C_In: not null access FlowControllerProperty_T);

    Octets_New

    function Octets_New return Octets_Ptr;

    Summary: Default Constructor.

    The default constructor initializes the newly created object with null value, zero length, and zero offset.

    Octets_New_W_Size

    function Octets_New_W_Size 
    (Size: Integer) return Octets_Ptr;

    Summary: Constructor that specifies the size of the allocated octets array.

    After this procedure is called, length and offset are set to zero.

    @param theLength <<in>> Size of the allocated octets array.

    Raises: IllegalArgumentException if size is negative

    Octets_Delete

    procedure Octets_Delete 
    (Self: Octets_Ptr);

    Summary: Destructor.

    KeyedString_New

    function KeyedString_New return KeyedString_Ptr;

    Summary: Default Constructor.

    The default constructor initializes the newly created object with empty key and value.

    KeyedString_New_W_Size

    function KeyedString_New_W_Size 
    (Key_Size: Integer;
    Size: Integer) return KeyedString_Ptr;

    Summary: Constructor that specifies the allocated sizes.

    The allocated strings are initialized to empty ("").

    key_size: <<in>> Size of the allocated key string (with NULL-terminated character).

    size: <<in>> Size of the allocated value string (with NULL-terminated character).

    Returns: A new DDS_KeyedString or NULL if failure.

    KeyedString_Delete

    procedure KeyedString_Delete 
    (Self: KeyedString_Ptr);

    Summary: Destructor.

    KeyedOctets_New

    function KeyedOctets_New return KeyedOctets_Ptr;

    Summary: Default Constructor.

    The default constructor initializes the newly created object with empty key, null value, zero length, and zero offset.

    KeyedOctets_New_W_Size

    function KeyedOctets_New_W_Size 
    (Key_Size: Integer;
    Size: Integer) return KeyedOctets_Ptr;

    Summary: Constructor that specifies the allocated sizes.

    After this procedure is called, key is initialized with the empty string and length and offset are set to zero.

    @param theLength <<in>> Size of the allocated octets array.

    Raises: IllegalArgumentException if size is negative

    KeyedOctets_Delete

    procedure KeyedOctets_Delete 
    (Self: KeyedOctets_Ptr);

    Summary: Destructor.