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.Sequences_Generic)

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

Tags_Seq (new DDS_Support.Sequences_Generic)

package Tags_Seq is new DDS_Support.Sequences_Generic
     (Tags_T,
      Tags_T_Access,
      DDS.Natural,
      1,
      Tags_T_Array);

Summary: Declares IDL sequence < DDS.Tag >


See also: DDS.Tag

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

DataRepresentationId_Seq (new DDS_Support.Sequences_Generic)

package DataRepresentationId_Seq is new DDS_Support.Sequences_Generic
     (DataRepresentationId_T,
      DataRepresentationId_T_Access,
      DDS.Natural,
      1,
      DataRepresentationId_T_Array);

Summary: Declares IDL sequence < DDS.DataRepresentationId_t >


See also: DDS.DataRepresentationId_t

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

Summary: Declares IDL sequence < DDS.Cookie_t > .


See also: FooSeq

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

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

MonitoringMetricSelection_Seq (new DDS_Support.Sequences_Generic)

package MonitoringMetricSelection_Seq is new DDS_Support.Sequences_Generic
     (MonitoringMetricSelection,
      MonitoringMetricSelection_Access,
      DDS.Natural,
      1,
      MonitoringMetricSelection_Array);

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;
      Representation     : aliased DataRepresentationQosPolicy;
      -- --- Extensions: ----------------------------------------------------
      Protocol           : aliased TopicProtocolQosPolicy;
   end record with Convention => C;

Ancestors:

Limited_Controlled

Primitive operations:

Adjust
GetInterface (overriding ndds_dds_c_dds_c_topic_h.DDS_TopicQos.DDS_TopicQos)

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.

Representation: Data representation policy, DDSDataRepresentationQosModule.

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;
      Representation         : aliased DataRepresentationQosPolicy;
      Data_Tags              : aliased DataTagQosPolicy;
      -- --- 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;
      Topic_Query_Dispatch   : aliased TopicQueryDispatchQosPolicy;
      Transfer_Mode          : aliased DataWriterTransferModeQosPolicy;
      Type_Support           : aliased TypeSupportQosPolicy;
   end record;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_publication_h.DDS_DataWriterQos.DDS_DataWriterQos)

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 \endif and DDS.Publisher.set_default_datawriter_qos and DDS.Publisher.set_default_datawriter_qos_with_profile will fail with DDS.RETCODE_INCONSISTENT_POLICY and \ifnot CPP2_LANGUAGE_ONLY 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.

Representation: Data representation policy, DDSDataRepresentationQosModule.

Data_Tags: DataTag policy, DDSDataTagQosModule.

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. See also ef_url_property_reference.

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.

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

Transfer_Mode: <<ext>> TransferMode policy, DDSDataWriterTransferModeQosModule.

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

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

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;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_publication_h.DDS_PublisherQos.DDS_PublisherQos)

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.

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;
      Representation         : aliased DataRepresentationQosPolicy;
      Type_Consistency       : aliased TypeConsistencyEnforcementQosPolicy;
      Data_Tags              : aliased DataTagQosPolicy;
      -- --- 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;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_subscription_h.DDS_DataReaderQos.DDS_DataReaderQos)

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

Representation: Data representation policy, DDSDataRepresentationQosModule.

Type_Consistency: Type consistency enforcement policy, DDSTypeConsistencyEnforcementQosModule

Data_Tags: DataTag policy, DDSDataTagQosModule.

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. See also ef_url_property_reference.

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;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_subscription_h.DDS_SubscriberQos.DDS_SubscriberQos)

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.

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;
      Partition         : aliased PartitionQosPolicy;
      User_Object       : aliased UserObjectQosPolicy;
      Protocol          : aliased DomainParticipantProtocolQosPolicy;
      Type_Support      : aliased TypeSupportQosPolicy;
   end record;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_domain_h.DDS_DomainParticipantQos.DDS_DomainParticipantQos)

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.

Property: <<ext>> Property policy, DDSPropertyQosModule. See also ef_url_property_reference.

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.

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 LoggingQosPolicy;
      monitoring      : aliased MonitoringQosPolicy;
   end record;

Ancestors:

Limited_Controlled

Primitive operations:

GetInterface (overriding ndds_dds_c_dds_c_domain_h.DDS_DomainParticipantFactoryQos.DDS_DomainParticipantFactoryQos)

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;

Unsigned_Short

type Unsigned_Short     is new Interfaces.Unsigned_16;

Unsigned_Long

type Unsigned_Long      is new Interfaces.Unsigned_32;

Unsigned_Long_Long

type Unsigned_Long_Long is new Interfaces.Unsigned_64;

Enum

type Enum               is new Interfaces.Unsigned_32;

Summary: Defines an enumerated data type.

Encoded as a signed 32-bit integer value. By default, the first enum identifier has the numeric value zero (0) (unless the value is provided explicitly). 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_Character;

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

A 16-bit quantity that contains a wide character encoded in UTF-16.

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;

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;

KeyedOctets

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

Wchars_Ptr

type Wchars_Ptr is access all Standard.Wide_Character
     with Convention => C;

Wide_String

type Wide_String is limited record
      Data : Wchars_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;

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_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

[range] [0,1000000000)

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

[range] [0,1000000000)

CompressionSettings_T

type CompressionSettings_T is record
      Compression_Ids              : aliased Unsigned_Long := 0;
      Writer_Compression_Level     : aliased Unsigned_Long := 10;
      Writer_Compression_Threshold : aliased Long := 0;
   end record with
     Convention => C;

Summary: <<ext>> Settings related to compressing user data.

QoS:
DDS.DataRepresentationQosPolicy

Compression_Ids: <<ext>> Mask that represents the compression algorithms enabled.

A bitmap that represents the compression algorithm IDs (DDS.CompressionIdMask) that are supported by the endpoint. The DDS.DataWriter creation will fail if more than one algorithm is provided.

If a DDS.DataWriter inherits multiple compression IDs from a DDS.Topic, only the least significant bit enabled will be inherited. This forces the following order of preference: DDS_COMPRESSION_ID_ZLIB, DDS_COMPRESSION_ID_BZIP2, DDS_COMPRESSION_ID_LZ4.

Interactions with Security and Batching: Currently, the only algorithm that is supported when compression and batching are enabled on the same DDS.DataWriter is DDS_COMPRESSION_ID_ZLIB.

The combination of compression, batching, and data protection is supported. First, compression is applied to the entire batch. Then, data protection is applied to the compressed batch.

Note: When DDS.DataWriterProtocolQosPolicy.serialize_key_with_dispose is enabled and a dispose message is sent, the serialized key is not compressed.

[default] For DDS.Topic, DDS.DataWriter a DDS.CompressionIdMask mask set to DDS_COMPRESSION_ID_MASK_NONE

[default] For DDS.DataReader a DDS.CompressionIdMask mask set to DDS_COMPRESSION_ID_MASK_ALL.

Writer_Compression_Level: <<ext>> The level of compression to use when compressing data.

Compression algorithms typically allow you to choose a level with which to compress the data. Each level has trade-offs between the resulting compression ratio and the speed of compression.

[range] [0, 10]

The value 1 represents the fastest compression time and the lowest compression ratio. The value 10 represents the slowest compression time but the highest compression ratio.

A value of 0 disables compression.

[default] DDS_COMPRESSION_LEVEL_BEST_COMPRESSION

Note: Only available for a DDS.DataWriter and DDS.Topic.

Writer_Compression_Threshold: <<ext>> The threshold, in bytes, above which a serialized sample will be eligible to be compressed.

Any sample with a serialized size greater than or equal to the threshold will be eligible to be compressed. All samples with an eligible serialized size will be compressed. Only if the compressed size is smaller than the serialized size will the sample be stored and sent compressed on the wire.

For batching we check the maximum serialized size of the batch, calculated as serialized_sample_max_size * DDS.BatchQosPolicy.max_samples

[range] [0, 2147483647] or DDS.LENGTH_UNLIMITED

Setting the threshold to DDS.LENGTH_UNLIMITED disables the compression.

[default] DDS_COMPRESSION_THRESHOLD_DEFAULT (8192)

Note: Only available for a DDS.DataWriter and DDS.Topic.

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.ndds_dds_c_dds_c_infrastructure_h.DDS_InstanceHandle_t;

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;

Guid_T_Access

type Guid_T_Access is access all Guid_T;

SequenceNumber_T

type SequenceNumber_T is record
      High : aliased DDS.Long := 0;
      Low  : aliased DDS.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,
      RETCODE_NOT_ALLOWED_BY_SECURITY
     ) with Default_Value => RETCODE_OK;

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), and the 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;

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;

Tags_T

type Tags_T is limited record
      Name  : aliased DDS.String;
      Value : aliased DDS.String;
   end record with Convention => C;

Tags_T_Access

type Tags_T_Access is access all Tags_T with Convention => C;

Tags_T_Array

type Tags_T_Array is array
     (Natural range <>) of aliased Tags_T;

DataTagQosPolicy

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

Summary: Stores (name, value) pairs that can be used to determine access permissions.

Entity:
DDS.DataReader DDS.DataWriter

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

Usage

The DATA_TAG QoS policy can be used to associate a set of tags in the form of (name, value) pairs with a DDS.DataReader or DDS.DataWriter. This is similar to the DDS.PropertyQosPolicy, except for the following differences:

  • Data tags are always propagated. You cannot select whether or not a particular pair should be propagated.

  • Data tags are not exposed to API functions, such as DDS.DataWriter.get_matched_subscription_data, that receive DDS.PublicationBuiltinTopicData or DDS.SubscriptionBuiltinTopicData as a parameter.

  • Connext passes data tags to the Access Control Security Plugin, which may use them to decide whether to allow or deny the corresponding entities.

    There are helper functions to facilitate working with data tags. See the DDSDataTagQosModule page.

    Value: Sequence of data tags.

    [default] An empty list.

  • 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;

    AllocationSettings_T

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

    AllocationSettings_T_Access

    type  AllocationSettings_T_Access is access all  AllocationSettings_T;

    DurabilityQosPolicyKind

    type DurabilityQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of durability

    QoS:
    DDS.DurabilityQosPolicy

    PersistentJournalKind

    type PersistentJournalKind is new Unsigned_Long;

    Summary: Sets the journal mode of the persistent storage.

    The rollback journal is used in SQLite to store the state of the persistent storage before a transaction is committed.

    QoS:
    DDS.DurabilityQosPolicy

    PersistentSynchronizationKind

    type PersistentSynchronizationKind is new Unsigned_Long;

    Summary: Determines the level of synchronization with the physical disk.

    QoS:
    DDS.DurabilityQosPolicy

    PersistentStorageSettings

    type PersistentStorageSettings is record
          Enable                           : aliased DDS.Boolean := False;
          File_Name                        : aliased DDS.String;
          Trace_File_Name                  : aliased DDS.String;
          Journal_Kind                     : aliased PersistentJournalKind := WAL_PERSISTENT_JOURNAL;
          Synchronization_Kind             : aliased PersistentSynchronizationKind := NORMAL_PERSISTENT_SYNCHRONIZATION;
          Vacuum                           : aliased DDS.Boolean := True;
          Restore                          : aliased DDS.Boolean := True;
          Writer_Instance_Cache_Allocation : aliased AllocationSettings_T := (-2, -2, -1);
          Writer_Sample_Cache_Allocation   : aliased AllocationSettings_T := (32, 32, -2);
          Writer_Memory_State              : aliased DDS.Boolean := True;
          Reader_Checkpoint_Frequency      : aliased Unsigned_Long := 1;
       end record with Convention => C;

    DurabilityQosPolicy

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

    DurabilityQosPolicy_Access

    type DurabilityQosPolicy_Access is access all DurabilityQosPolicy;

    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;

    DeadlineQosPolicy

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

    LatencyBudgetQosPolicy

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

    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;

    OwnershipStrengthQosPolicy

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

    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;

    TimeBasedFilterQosPolicy

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

    PartitionQosPolicy

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

    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

    InstanceStateRecoveryKind

    type InstanceStateRecoveryKind is (NO_INSTANCE_STATE_RECOVERY, RECOVER_INSTANCE_STATE_RECOVERY);

    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.

    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;
          Instance_State_Recovery_Kind : aliased InstanceStateRecoveryKind := NO_INSTANCE_STATE_RECOVERY;
       end record with Convention => C;

    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 with Convention => C;

    HistoryQosPolicyKind

    type HistoryQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of history

    QoS:
    DDS.HistoryQosPolicy

    HistoryQosPolicy

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

    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;

    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 with Convention => C;

    TransportPriorityQosPolicy

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

    LifespanQosPolicy

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

    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;

    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;
          Autopurge_Nowriter_Instances_Delay : aliased Duration_T := DURATION_ZERO;
       end record with Convention => C;

    EntityFactoryQosPolicy

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

    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;

    RtpsReliableWriterProtocol_T

    type RtpsReliableWriterProtocol_T is record
          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;
          Disable_Repair_Piggyback_Heartbeat                                : aliased Boolean := False;
       end record with Convention => C;

    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;

    DataRepresentationId_T

    type DataRepresentationId_T is new RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataRepresentationId_t
         with Convention => C;

    Summary: A two-byte signed integer that identifies a data representation.

    DataRepresentationId_T_Access

    type DataRepresentationId_T_Access is access all DataRepresentationId_T;

    DataRepresentationId_T_Array

    type DataRepresentationId_T_Array is array
         (Natural range <>) of aliased DataRepresentationId_T;

    DataRepresentationQosPolicy

    type DataRepresentationQosPolicy is limited record
          Value                : aliased DataRepresentationId_Seq.Sequence;
          Compression_Settings : aliased CompressionSettings_T := COMPRESSION_SETTINGS_T_DEFAULT;
       end record with Convention => C;

    TransportSelectionQosPolicy

    type TransportSelectionQosPolicy is record
          Enabled_Transports : aliased DDS.String_Seq.Sequence := DDS.String_Seq.DEFAULT_SEQUENCE;
       end record with Convention => C;

    TransportUnicastQosPolicy

    type TransportUnicastQosPolicy is record
          Value :  TransportUnicastSettings_Seq.Sequence;
       end record with Convention => C;

    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 := TransportMulticastSettings_Seq.DEFAULT_SEQUENCE;
          Kind  : TransportMulticastQosPolicyKind := AUTOMATIC_TRANSPORT_MULTICAST_QOS;
       end record with Convention => C;

    TransportMulticastMappingQosPolicy

    type TransportMulticastMappingQosPolicy is record
          Value : TransportMulticastMapping_Seq.Sequence;
       end record with Convention => C;

    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. These alias names are case sensitive and should be written in lowercase.

    [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

    [range] [0, MAX_UINT]

    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;

    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].

    Note: On Windows, you should avoid using ports 49152 through 65535 for inbound traffic. dds's ephemeral ports (see "Ports Used for Communication" in the User's Manual ) may be within that range (see https://msdn.microsoft.com/en-us/library/windows/desktop/ms737550(v=vs.85).aspx). With the default RtpsWellKnownPorts settings, port 49152 corresponds to domain ID 167, so using domain IDs 168 through 232 on Windows introduces the risk of a port collision and failure to create the Domain Participant when using multicast discovery. You may see this error:

    RTIOsapiSocket_bindWithIP:OS bind() failure, error 0X271D: An attempt was made to access a socket in a way forbidden by its access permissions.

    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;

    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.

    DataReaderResourceLimitsInstanceReplacementSettings

    type DataReaderResourceLimitsInstanceReplacementSettings is record
          Alive_Instance_Removal      : aliased Unsigned_Long := 0;
          Disposed_Instance_Removal   : aliased Unsigned_Long := 0;
          No_Writers_Instance_Removal : aliased Unsigned_Long := 1;
       end record with
         Convention => C;

    Summary: Instance replacement kind applied to each instance state.

    [default]

    • DDS.DataReaderResourceLimitsInstanceReplacementSettings.alive_instance_removal = DDS.NO_INSTANCE_REMOVAL
    • DDS.DataReaderResourceLimitsInstanceReplacementSettings.disposed_instance_removal = DDS.EMPTY_INSTANCE_REMOVAL
    • DDS.DataReaderResourceLimitsInstanceReplacementSettings.no_writers_instance_removal = DDS.EMPTY_INSTANCE_REMOVAL


    See also: DDS.DataReaderResourceLimitsQosPolicy.instance_replacement

    Alive_Instance_Removal: Removal kind applied to alive (DDS.ALIVE_INSTANCE_STATE) instances.

    [default] DDS.NO_INSTANCE_REMOVAL

    Disposed_Instance_Removal: Removal kind applied to disposed (DDS.NOT_ALIVE_DISPOSED_INSTANCE_STATE) instances.

    [default] DDS.EMPTY_INSTANCE_REMOVAL

    No_Writers_Instance_Removal: Removal kind applied to fully-unregistered (DDS.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE) instances.

    [default] DDS.EMPTY_INSTANCE_REMOVAL

    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 := 1;
          Keep_Minimum_State_For_Instances                    : aliased DDS.Boolean := True;
          Initial_Topic_Queries                               : aliased Long := 1;
          Max_Topic_Queries                                   : aliased Long := -1;
          Shmem_Ref_Transfer_Mode_Attached_Segment_Allocation : aliased AllocationSettings_T := AllocationSettings_T_AUTO;
          Instance_Replacement                                : aliased DataReaderResourceLimitsInstanceReplacementSettings := DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT;
          Autopurge_Remote_Not_Alive_Writer_Delay             : aliased Duration_T := DURATION_AUTO;
          Autopurge_Remote_Virtual_Writer_Delay               : aliased Duration_T := DURATION_INFINITE;
       end record with Convention => C;

    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;
          Writer_Loaned_Sample_Allocation     : aliased AllocationSettings_T := AllocationSettings_T_AUTO;
          Initialize_Writer_Loaned_Sample     : aliased DDS.Boolean := False;
       end record with Convention => C;

    ServiceQosPolicyKind

    type ServiceQosPolicyKind is new Unsigned_Long;

    Summary: Kinds of service

    QoS:
    DDS.ServiceQosPolicy

    ServiceQosPolicy

    type ServiceQosPolicy is record
          Kind : ServiceQosPolicyKind := NO_SERVICE_QOS;
       end record  with Convention => C;

    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;

    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;

    SystemResourceLimitsQosPolicy

    type SystemResourceLimitsQosPolicy is record
          Max_Objects_Per_Thread     : Long := 261120; -- note set by the environment variable  NDDS_MAX_OBJECTS_PER_THREAD
          Initial_Objects_Per_Thread : Long := 1024;
       end record with Convention => C;

    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 := 0;
          Type_Object_Max_Serialized_Length                     : aliased Long := 8192;
          Serialized_Type_Object_Dynamic_Allocation_Threshold   : aliased Long := 8192;
          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;
          Writer_Data_Tag_List_Max_Length                       : aliased Long := 0;
          Writer_Data_Tag_String_Max_Length                     : aliased Long := 0;
          Reader_Data_Tag_List_Max_Length                       : aliased Long := 0;
          Reader_Data_Tag_String_Max_Length                     : aliased Long := 0;
          Shmem_Ref_Transfer_Mode_Max_Segments                  : aliased Unsigned_Long := RTIDDS.Low_Level.ndds_pres_pres_participant_h.PRES_SHMEM_REF_TRANSFER_MODE_MAX_SEGMENTS;
       end record with Convention => C;

    EventQosPolicy

    type EventQosPolicy is record
          Thread        : aliased ThreadSettings_T;
          Initial_Count : aliased Long := 256;
          Max_Count     : aliased Long := -1;
       end record with Convention => C;

    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;

    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;

    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;

    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;

    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;

    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

    DiscoveryConfigBuiltinChannelKindMask

    type DiscoveryConfigBuiltinChannelKindMask is mod 2 ** 32;

    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;

    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;

    RtpsReliableWriterProtocol

    type RtpsReliableWriterProtocol is record
          Low_Watermark                                              : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2186
          High_Watermark                                             : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2190
          Heartbeat_Period                                           : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2194
          Fast_Heartbeat_Period                                      : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2198
          Late_Joiner_Heartbeat_Period                               : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2202
          Virtual_Heartbeat_Period                                   : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2206
          Samples_Per_Virtual_Heartbeat                              : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2210
          Max_Heartbeat_Retries                                      : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2214
          Inactivate_Nonprogressing_Readers                          : aliased Boolean := False;  -- ndds/dds_c/dds_c_infrastructure.h:2218
          Heartbeats_Per_Max_Samples                                 : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2222
          Min_Nack_Response_Delay                                    : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2226
          Max_Nack_Response_Delay                                    : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2230
          Nack_Suppression_Duration                                  : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2234
          Max_Bytes_Per_Nack_Response                                : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2238
          Disable_Positive_Acks_Min_Sample_Keep_Duration             : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2242
          Disable_Positive_Acks_Max_Sample_Keep_Duration             : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2246
          Disable_Positive_Acks_Sample_Min_Separation                : aliased Duration_T := DURATION_ZERO;  -- ndds/dds_c/dds_c_infrastructure.h:2250
          Disable_Positive_Acks_Enable_Adaptive_Sample_Keep_Duration : aliased Boolean := False;  -- ndds/dds_c/dds_c_infrastructure.h:2254
          Disable_Positive_Acks_Enable_Spin_Wait                     : aliased Boolean := False;  -- ndds/dds_c/dds_c_infrastructure.h:2258
          Disable_Positive_Acks_Decrease_Sample_Keep_Duration_Factor : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2262
          Disable_Positive_Acks_Increase_Sample_Keep_Duration_Factor : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2266
          Min_Send_Window_Size                                       : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2270
          Max_Send_Window_Size                                       : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2274
          Send_Window_Update_Period                                  : aliased Duration_T := DURATION_ZERO;
          Send_Window_Increase_Factor                                : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2282
          Send_Window_Decrease_Factor                                : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2286
          Enable_Multicast_Periodic_Heartbeat                        : aliased Boolean := False;  -- ndds/dds_c/dds_c_infrastructure.h:2290
          Multicast_Resend_Threshold                                 : aliased Long := 0;  -- ndds/dds_c/dds_c_infrastructure.h:2294
          Disable_Repair_Piggyback_Heartbeat                         : aliased Boolean := False;  -- ndds/dds_c/dds_c_infrastructure.h:2298
       end record
         with Convention => C;

    RtpsReliableReaderProtocol

    type RtpsReliableReaderProtocol is record
          Min_Heartbeat_Response_Delay       : aliased Duration_T := DURATION_ZERO;
          Max_Heartbeat_Response_Delay       : aliased Duration_T := DURATION_ZERO;
          Heartbeat_Suppression_Duration     : aliased Duration_T := DURATION_ZERO;
          Nack_Period                        : aliased Duration_T := DURATION_ZERO;
          Receive_Window_Size                : aliased Long := 0;
          Round_Trip_Time                    : aliased Duration_T := DURATION_ZERO;
          App_Ack_Period                     : aliased Duration_T := DURATION_ZERO;
          Min_App_Ack_Response_Keep_Duration : aliased Duration_T := DURATION_ZERO;
          Samples_Per_App_Ack                : aliased Long := 0;
       end record
         with Convention => C;

    BuiltinTopicReaderResourceLimits

    type BuiltinTopicReaderResourceLimits is record
          Initial_Samples                          : aliased Long := 0;
          Max_Samples                              : aliased Long := 0;
          Initial_Infos                            : aliased Long := 0;
          Max_Infos                                : aliased Long := 0;
          Initial_Outstanding_Reads                : aliased Long := 0;
          Max_Outstanding_Reads                    : aliased Long := 0;
          Max_Samples_Per_Read                     : aliased Long := 0;
          Disable_Fragmentation_Support            : aliased Boolean := False;
          Max_Fragmented_Samples                   : aliased Long := 0;
          Initial_Fragmented_Samples               : aliased Long := 0;
          Max_Fragmented_Samples_Per_Remote_Writer : aliased Long := 0;
          Max_Fragments_Per_Sample                 : aliased Long := 0;
          Dynamically_Allocate_Fragmented_Samples  : aliased Boolean := False;
       end record
         with Convention => C;

    DiscoveryConfigQosPolicy

    type DiscoveryConfigQosPolicy is record
          Participant_Liveliness_Lease_Duration                  : aliased Duration_T := (100, 0);
          Participant_Liveliness_Assert_Period                   : aliased Duration_T := (30, 0);
          Participant_Announcement_Period                        : aliased Duration_T;
          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;
          New_Remote_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 := 0;
          Builtin_Discovery_Plugins                              : aliased DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT;
          Enabled_Builtin_Channels                               : aliased DiscoveryConfigBuiltinChannelKindMask := 2#0000_0000_0000_0000#;
          Participant_Message_Reader_Reliability_Kind            : aliased ReliabilityQosPolicyKind  := BEST_EFFORT_RELIABILITY_QOS;
          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 := False;
          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;
          Secure_Volatile_Writer                                 : aliased RtpsReliableWriterProtocol_T;
          Secure_Volatile_Writer_Publish_Mode                    : aliased PublishModeQosPolicy;
          Secure_Volatile_Reader                                 : aliased RtpsReliableReaderProtocol_T;
          Endpoint_Type_Object_LB_Serialization_Threshold        : aliased Long := 0;
          Dns_Tracker_Polling_Period                             : aliased Duration_T;
          Participant_Configuration_Writer_Publish_Mode          : aliased PublishModeQosPolicy;
          Participant_Configuration_Writer                       : aliased RtpsReliableWriterProtocol;
          Participant_Configuration_Writer_Data_Lifecycle        : aliased WriterDataLifecycleQosPolicy;
          Participant_Configuration_Reader                       : aliased RtpsReliableReaderProtocol;
          Participant_Configuration_Reader_Resource_Limits       : aliased BuiltinTopicReaderResourceLimits;
          Sedp_Rely_On_Spdp_Only                                 : aliased Boolean := False;
          Publication_Writer_Latency_Budget                      : aliased LatencyBudgetQosPolicy;
          Publication_Writer_Push_On_Write                       : aliased Boolean := True;
          Subscription_Writer_Latency_Budget                     : aliased LatencyBudgetQosPolicy;
          Subscription_Writer_Push_On_Write                      : aliased Boolean := False;
          Participant_State_Writer                               : aliased RtpsReliableWriterProtocol_T;
          Participant_State_Writer_Latency_Budget                : aliased LatencyBudgetQosPolicy;
          Participant_State_Writer_Push_On_Write                 : aliased Boolean := False;
          Participant_State_Writer_Publish_Mode                  : aliased PublishModeQosPolicy;
          Participant_Proxy_Reader                               : aliased RtpsReliableReaderProtocol_T;
          Participant_Proxy_Reader_Fragmentation_Resource_Limits : aliased DiscoveryBuiltinReaderFragmentationResourceLimits_T;
       end record with Convention => C;

    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;

    DataWriterShmemRefTransferModeSettings

    type DataWriterShmemRefTransferModeSettings is record
          Enable_Data_Consistency_Check : aliased DDS.Boolean;
       end record with Convention => C;

    DataWriterShmemRefTransferModeSettings_Access

    type DataWriterShmemRefTransferModeSettings_Access is access all DataWriterShmemRefTransferModeSettings;

    DataWriterTransferModeQosPolicy

    type DataWriterTransferModeQosPolicy is record
          Shmem_Ref_Settings : aliased DataWriterShmemRefTransferModeSettings;
       end record with Convention => C;

    DataWriterTransferModeQosPolicy_Access

    type DataWriterTransferModeQosPolicy_Access is access all DataWriterTransferModeQosPolicy;

    TopicQueryDispatchQosPolicy

    type TopicQueryDispatchQosPolicy is record
          Enable                      : aliased DDS.Boolean := False;
          Publication_Period          : aliased Duration_T := (16#0000_0001#, 16#0000_0000#);
          Samples_Per_Period          : aliased DDS.Long := -1;
       end record with Convention => C;

    BatchQosPolicy

    type BatchQosPolicy is record
          Enable                      : aliased DDS.Boolean := False;
          Max_Data_Bytes              : aliased DDS.Long := 1024;
          Max_Meta_Data_Bytes         : aliased DDS.Long := LENGTH_UNLIMITED;
          Max_Samples                 : aliased DDS.Long := LENGTH_UNLIMITED;
          Max_Flush_Delay             : aliased Duration_T := DURATION_INFINITE;
          Source_Timestamp_Resolution : aliased Duration_T := DURATION_INFINITE;
          Thread_Safe_Write           : aliased DDS.Boolean := True;
       end record with Convention => C;

    TypeConsistencyKind

    type TypeConsistencyKind is new Unsigned_Long;

    Summary: Kinds of type consistency

    QoS:
    DDS.TypeConsistencyEnforcementQosPolicy

    TypeConsistencyEnforcementQosPolicy

    type TypeConsistencyEnforcementQosPolicy is record
          Kind                      : aliased TypeConsistencyKind := ALLOW_TYPE_COERCION;
          Ignore_Sequence_Bounds    : aliased Boolean := False;
          Ignore_String_Bounds      : aliased Boolean := False;
          Ignore_Member_Names       : aliased Boolean := False;
          Prevent_Type_Widening     : aliased Boolean := False;
          Force_Type_Validation     : aliased Boolean := False;
          Ignore_Enum_Literal_Names : aliased Boolean := False;
       end record with Convention => C;

    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;

    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;

    Property_T

    type Property_T is record
          Name      : aliased DDS.String;
          Value     : aliased DDS.String;
          Propagate : aliased DDS.Boolean := False;
       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;

    PropertyQosPolicy_Access

    type PropertyQosPolicy_Access is access all PropertyQosPolicy;

    WaitSetProperty_T

    type WaitSetProperty_T is record
          Max_Event_Count : aliased Long := 0;
          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.

    The role name can be at most 255 characters in length.

    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;

    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;

    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;

    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;

    Summary: <<ext>> Sequence of bytes.

    Value: a sequence of octets

    [default] Empty (zero-sized)

    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

    subtype SampleFlag is SampleFlagBits;

    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 := Time_Invalid;
          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;
          Related_Epoch           : aliased DDS.SequenceNumber_T := SEQUENCE_NUMBER_ZERO;
       end record with Convention => C;

    WriteParams_T_Access

    type WriteParams_T_Access is access all WriteParams_T;

    TypeCode

    type TypeCode is private;

    TypeCode_Access

    type TypeCode_Access is access all TypeCode;

    TypeObject

    type TypeObject is private;

    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;
          Message_Size_Max : aliased Long := 1024;
       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;

    ParticipantTrustAttributesMask

    type ParticipantTrustAttributesMask is mod 2 ** 32;

    PluginParticipantTrustAttributesMask

    type PluginParticipantTrustAttributesMask is mod 2 ** 32;

    ParticipantTrustProtectionInfo

    type ParticipantTrustProtectionInfo is record
          Bitmask           : aliased ParticipantTrustAttributesMask := 0;
          Plugin_Bitmask    : aliased PluginParticipantTrustAttributesMask := 0;
       end record
         with Convention => C;

    EndpointTrustAttributesMask

    type EndpointTrustAttributesMask is mod 2 ** 32;

    PluginEndpointTrustAttributesMask

    type PluginEndpointTrustAttributesMask is mod 2 ** 32;

    EndpointTrustProtectionInfo

    type EndpointTrustProtectionInfo is record
          Bitmask        : aliased EndpointTrustAttributesMask := 0;
          Plugin_Bitmask : aliased PluginEndpointTrustAttributesMask := 0;
       end record
         with Convention => C;

    TrustAlgorithmBit

    type TrustAlgorithmBit is mod 2 ** 32;

    TrustAlgorithmSet

    type TrustAlgorithmSet is mod 2 ** 32;

    TrustAlgorithmRequirements

    type TrustAlgorithmRequirements is record
          Supported_Mask : aliased TrustAlgorithmSet := 0;
          Required_Mask  : aliased TrustAlgorithmSet := 0;
       end record
         with Convention => C;

    ParticipantTrustSignatureAlgorithmInfo

    type ParticipantTrustSignatureAlgorithmInfo is record
          Trust_Chain  : aliased TrustAlgorithmRequirements;
          Message_Auth : aliased TrustAlgorithmRequirements;
       end record
         with Convention => C;

    ParticipantTrustKeyEstablishmentAlgorithmInfo

    type ParticipantTrustKeyEstablishmentAlgorithmInfo is record
          Shared_Secret : aliased TrustAlgorithmRequirements;
       end record
         with Convention => C;

    ParticipantTrustInterceptorAlgorithmInfo

    type ParticipantTrustInterceptorAlgorithmInfo is record
          Supported_Mask                         : aliased TrustAlgorithmSet := 0;
          Builtin_Endpoints_Required_Mask        : aliased TrustAlgorithmSet := 0;
          Builtin_Kx_Endpoints_Required_Mask     : aliased TrustAlgorithmSet := 0;
          User_Endpoints_Default_Required_Mask   : aliased TrustAlgorithmSet := 0;
       end record
         with Convention => C;

    ParticipantTrustAlgorithmInfo

    type ParticipantTrustAlgorithmInfo is record
          Signature         : aliased ParticipantTrustSignatureAlgorithmInfo;
          Key_Establishment : aliased ParticipantTrustKeyEstablishmentAlgorithmInfo;
          Interceptor       : aliased ParticipantTrustInterceptorAlgorithmInfo;
       end record
         with Convention => C_Pass_By_Copy;

    EndpointTrustInterceptorAlgorithmInfo

    type EndpointTrustInterceptorAlgorithmInfo is record
          Required_Mask  : aliased TrustAlgorithmSet := 0;
          Supported_Mask : aliased TrustAlgorithmSet := 0;
       end record
         with Convention => C_Pass_By_Copy;

    EndpointTrustAlgorithmInfo

    type EndpointTrustAlgorithmInfo is record
          Interceptor : aliased EndpointTrustInterceptorAlgorithmInfo;
       end record
         with Convention => C_Pass_By_Copy;

    ParticipantBuiltinTopicData

    type ParticipantBuiltinTopicData is record
          Key                            : aliased BuiltinTopicKey_T;
          User_Data                      : aliased UserDataQosPolicy;
          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;
          Participant_Name               : aliased EntityNameQosPolicy;
          Domain_Id                      : aliased DomainId_T := 0;
          Transport_Info                 : aliased TransportInfo_Seq.Sequence;
          Reachability_Lease_Duration    : aliased Duration_T;
          Partition                      : aliased PartitionQosPolicy;
          Trust_Protection_Info          : aliased ParticipantTrustProtectionInfo;
          Trust_Algorithm_Info           : aliased ParticipantTrustAlgorithmInfo;
          Partial_Configuration          : aliased Boolean := False;
          Vendor_Builtin_Endpoints       : aliased Unsigned_Long := 0;
          Service                        : aliased ServiceQosPolicy;
       end record with Convention => C;

    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;
          Representation            : aliased DataRepresentationQosPolicy;
       end record with Convention => C;

    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 Octet_Seq.Sequence;
       end record with Convention => C;

    ServiceRequestInternalTopicData_Access

    type ServiceRequestInternalTopicData_Access is access all ServiceRequestInternalTopicData;

    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;
          Representation            : aliased DataRepresentationQosPolicy;
          Data_Tags                 : aliased DataTagQosPolicy;
          --  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;
          Trust_Protection_Info     : aliased EndpointTrustProtectionInfo;
          Trust_Algorithm_Info      : aliased EndpointTrustAlgorithmInfo;
    
       end record with Convention => C;

    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;
          Representation          : aliased DataRepresentationQosPolicy;
          Data_Tags               : aliased DataTagQosPolicy;
          --  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;
          Trust_Protection_Info   : aliased EndpointTrustProtectionInfo;
          Trust_Algorithm_Info    : aliased EndpointTrustAlgorithmInfo;
       end record with Convention => C;

    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;

    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;

    LivelinessLostStatus

    type LivelinessLostStatus is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
       end record with Convention => C;

    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;

    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;

    ReliableWriterCacheEventCount

    type ReliableWriterCacheEventCount is record
          Total_Count        : aliased Long := 0;
          Total_Count_Change : aliased Long := 0;
       end record with Convention => C;

    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;
          Replaced_Unacknowledged_Sample_Count : aliased Long_Long := 0;
       end record with Convention => C;

    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 with Convention => C;

    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 with Convention => C;

    AcknowledgmentInfo_Access

    type AcknowledgmentInfo_Access is access all AcknowledgmentInfo;

    ServiceRequestAcceptedStatus

    type ServiceRequestAcceptedStatus is new RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ServiceRequestAcceptedStatus;

    ServiceRequestAcceptedStatus_Access

    type ServiceRequestAcceptedStatus_Access is access all  ServiceRequestAcceptedStatus with Storage_Size => 0;

    PublisherQos_Access

    type PublisherQos_Access is access PublisherQos;

    DataWriterCacheStatus

    type DataWriterCacheStatus is record
          Sample_Count_Peak                : aliased Long_Long := 0;
          Sample_Count                     : aliased Long_Long := 0;
          Alive_Instance_Count             : aliased Long_Long := 0;
          Alive_Instance_Count_Peak        : aliased Long_Long := 0;
          Disposed_Instance_Count          : aliased Long_Long := 0;
          Disposed_Instance_Count_Peak     : aliased Long_Long := 0;
          Unregistered_Instance_Count      : aliased Long_Long := 0;
          Unregistered_Instance_Count_Peak : aliased Long_Long := 0;
       end record with Convention => C;

    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;
          Pushed_Fragment_Count                                : aliased DDS.Long_Long := 0;
          Pushed_Fragment_Bytes                                : aliased DDS.Long_Long := 0;
          Pulled_Fragment_Count                                : aliased DDS.Long_Long := 0;
          Pulled_Fragment_Bytes                                : aliased DDS.Long_Long := 0;
          Received_Nack_Fragment_Count                         : aliased DDS.Long_Long := 0;
          Received_Nack_Fragment_Bytes                         : aliased DDS.Long_Long := 0;
       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 with Convention => C;

    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 with Convention => C;

    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 with Convention => C;

    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 with Convention => C;

    SampleRejectedStatusKind

    type SampleRejectedStatusKind is
         (NOT_REJECTED,
          REJECTED_BY_INSTANCES_LIMIT,
          REJECTED_BY_SAMPLES_LIMIT,
          REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT,
          REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT,
          REJECTED_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT,
          REJECTED_BY_DECODE_FAILURE);

    Summary: Kinds of reasons for rejecting a sample.

    NOT_REJECTED: The sample was not rejected.

    REJECTED_BY_INSTANCES_LIMIT: Connext DDS does not reject samples based on instance limits (DDS.ResourceLimitsQosPolicy.max_instances), so this value will never be used.
    See also: DDS.LOST_BY_INSTANCES_LIMIT

    REJECTED_BY_SAMPLES_LIMIT: When using DDS.RELIABLE_RELIABILITY_QOS: A resource limit on the number of samples (DDS.ResourceLimitsQosPolicy.max_samples) was reached. When using DDS.BEST_EFFORT_RELIABILITY_QOS, reaching DDS.ResourceLimitsQosPolicy.max_samples will trigger a loss, not a rejection, with reason DDS.LOST_BY_SAMPLES_LIMIT.


    See also: DDS.ResourceLimitsQosPolicy

    REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT: When using DDS.RELIABLE_RELIABILITY_QOS: A resource limit on the number of samples per instance (DDS.ResourceLimitsQosPolicy.max_samples_per_instance) was reached. When using DDS.BEST_EFFORT_RELIABILITY_QOS, reaching DDS.ResourceLimitsQosPolicy.max_samples_per_instance will trigger a loss, not a rejection, with reason DDS.LOST_BY_SAMPLES_PER_INSTANCE_LIMIT.


    See also: ResourceLimitsQosPolicy

    REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT: When using DDS.RELIABLE_RELIABILITY_QOS: a resource limit on the number of samples from a given remote writer that a DDS.DataReader may store (DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer) was reached. When using DDS.BEST_EFFORT_RELIABILITY_QOS, reaching DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer will trigger a loss, not a rejection, with reason DDS.LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT.

    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 field is currently not used.)

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    Summary: When using DDS.RELIABLE_RELIABILITY_QOS: A received sample was rejected because it could not be decoded. When using DDS.BEST_EFFORT_RELIABILITY_QOS, the sample will be lost, not rejected, with reason DDS.LOST_BY_DECODE_FAILURE.

    If a sample was rejected for this reason and the DDS.DataWriter set DDS.DataWriterProtocolQosPolicy.disable_inline_keyhash to DDS.BOOLEAN_TRUE, then DDS.SampleRejectedStatus.last_instance_handle may not be correct if the sample was encrypted.

    This constant is an extension to the DDS standard.

    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 with Convention => C;

    SubscriptionMatchedStatus

    type SubscriptionMatchedStatus 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_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 with the same DDS.Topic, same or compatible data type, and an offered QoS that is compatible with that requested by the DDS.DataReader. (For information on compatible data types, see the Getting Started Guide, Addendum for Extensible Types .)

    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 of the following reasons:

    • The DDS.DomainParticipant containing the matched DDS.DataWriter has lost liveliness.
    • This DataReader or the matched DataWriter has changed QoS such that the entities are now incompatible.
    • The matched DataWriter has been deleted.

    This status may reflect changes from multiple match or unmatch events, and the DDS.SubscriptionMatchedStatus.current_count_change can be used to determine the number of changes since the listener was called back or the status was checked.

    Note: A DataWriter's loss of liveliness (which is determined by DDS.LivelinessQosPolicyKind) does not trigger an unmatch event. So a DataWriter may still match even though its liveliness is lost.

    Total_Count: The total cumulative number of times that this DDS.DataReader discovered a "match" with a DDS.DataWriter.

    This number increases whenever a new match is discovered. It does not decrease when an existing match goes away for any of the reasons described in DDS.SubscriptionMatchedStatus.

    Total_Count_Change: The changes in total_count since the last time the listener was called or the status was read.

    Note that this number will never be negative (because it's the total number of times the DataReader ever matched with a DataWriter).

    Current_Count: The current number of DataWriters with which the DDS.DataReader is matched.

    This number increases when a new match is discovered and decreases when an existing match goes away for any of the reasons described in DDS.SubscriptionMatchedStatus.

    Current_Count_Peak: <<ext>> Greatest number of DataWriters that matched this DataReader simultaneously.

    That is, there was no moment in time when more than this many DataWriters matched this DataReader. (As a result, total_count can be higher than current_count_peak.)

    Current_Count_Change: The change in current_count since the last time the listener was called or the status was read.

    Note that a negative current_count_change means that one or more DataWriters have become unmatched for one or more of the reasons described in DDS.SubscriptionMatchedStatus.

    Last_Publication_Handle: This InstanceHandle can be used to look up which remote DDS.DataWriter was the last to cause this DataReader's status to change, using DDS.DataReader.get_matched_publication_data.

    If the DataWriter no longer matches this DataReader due to any of the reasons in DDS.SubscriptionMatchedStatus except incompatible QoS, then the DataWriter has been purged from this DataReader's DomainParticipant discovery database. (See the "Discovery Overview" section of the User's Manual .) In that case, the DDS.DataReader.get_matched_publication_data method will not be able to return information about the DataWriter. The only way to get information about the lost DataWriter is if you cached the information previously.

    DataReaderCacheStatus

    type DataReaderCacheStatus is record
          Sample_Count_Peak                                         : aliased Long_Long := 0;
          Sample_Count                                              : aliased Long_Long := 0;
          Old_Source_Timestamp_Dropped_Sample_Count                 : aliased Long_Long := 0;
          Tolerance_Source_Timestamp_Dropped_Sample_Count           : aliased Long_Long := 0;
          Ownership_Dropped_Sample_Count                            : aliased Long_Long := 0;
          Content_Filter_Dropped_Sample_Count                       : aliased Long_Long := 0;
          Time_Based_Filter_Dropped_Sample_Count                    : aliased Long_Long := 0;
          Expired_Dropped_Sample_Count                              : aliased Long_Long := 0;
          Virtual_Duplicate_Dropped_Sample_Count                    : aliased Long_Long := 0;
          Replaced_Dropped_Sample_Count                             : aliased Long_Long := 0;
          Writer_Removed_Batch_Sample_Dropped_Sample_Count          : aliased Long_Long := 0;
          Total_Samples_Dropped_By_Instance_Replacement             : aliased Long_Long := 0;
          Alive_Instance_Count                                      : aliased Long_Long := 0;
          Alive_Instance_Count_Peak                                 : aliased Long_Long := 0;
          No_Writers_Instance_Count                                 : aliased Long_Long := 0;
          No_Writers_Instance_Count_Peak                            : aliased Long_Long := 0;
          Disposed_Instance_Count                                   : aliased Long_Long := 0;
          Disposed_Instance_Count_Peak                              : aliased Long_Long := 0;
          Detached_Instance_Count                                   : aliased Long_Long := 0;
          Detached_Instance_Count_Peak                              : aliased Long_Long := 0;
          Compressed_Sample_Count                                   : aliased Long_Long := 0;
       end record with Convention => C;

    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;
          Out_Of_Range_Rejected_Sample_Count     : aliased Long_Long := 0;
          Received_Fragment_Count                : aliased Long_Long := 0;
          Dropped_Fragment_Count                 : aliased Long_Long := 0;
          Reassembled_Sample_Count               : aliased Long_Long := 0;
          Sent_Nack_Fragment_Count               : aliased Long_Long := 0;
          Sent_Nack_Fragment_Bytes               : aliased Long_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

    Note that when data is fragmented, this statistic is updated when all of the fragments required to reassemble a sample are received, not when individual fragments are received.

    received_sample_count_change: The change in DDS.DataReaderProtocolStatus.received_sample_count since the last time the status was read.


    See also: DDS.DataReaderProtocolStatus.received_sample_count

    Note that when data is fragmented, this statistic is updated when all of the fragments required to reassemble a sample are received, not when individual fragments are received.

    received_sample_bytes: The number of bytes received by a DataReader.


    See also: DDS.DataReaderProtocolStatus.received_sample_count

    Note that when data is fragmented, this statistic is updated upon the receipt of each fragment, not when a sample is reassembled.

    received_sample_bytes_change: The change in DDS.DataReaderProtocolStatus.received_sample_bytes since the last time the status was read.


    See also: DDS.DataReaderProtocolStatus.received_sample_count_change

    Note that when data is fragmented, this statistic is updated upon the receipt of each fragment, not when a sample is reassembled.

    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 change in DDS.DataReaderProtocolStatus.duplicate_sample_count 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 change in DDS.DataReaderProtocolStatus.duplicate_sample_bytes 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: \deprecated. See: DDS.DataReaderCacheStatus.time_based_filter_dropped_sample_count DDS.DataReaderCacheStatus.content_filter_dropped_sample_count

    filtered_sample_count_change: \deprecated. See: DDS.DataReaderCacheStatus.time_based_filter_dropped_sample_count DDS.DataReaderCacheStatus.content_filter_dropped_sample_count

    filtered_sample_bytes: \deprecated. See: DDS.DataReaderCacheStatus.time_based_filter_dropped_sample_count DDS.DataReaderCacheStatus.content_filter_dropped_sample_count

    filtered_sample_bytes_change: \deprecated. See: DDS.DataReaderCacheStatus.time_based_filter_dropped_sample_count DDS.DataReaderCacheStatus.content_filter_dropped_sample_count

    received_heartbeat_count: The number of Heartbeats from a remote DataWriter received by a local DataReader.

    received_heartbeat_count_change: The change in DDS.DataReaderProtocolStatus.received_heartbeat_count 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 change in DDS.DataReaderProtocolStatus.received_heartbeat_bytes 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 change in DDS.DataReaderProtocolStatus.sent_ack_count 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 change in DDS.DataReaderProtocolStatus.sent_ack_bytes 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 change in DDS.DataReaderProtocolStatus.sent_nack_count 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 change in DDS.DataReaderProtocolStatus.sent_nack_bytes 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 change in DDS.DataReaderProtocolStatus.received_gap_count 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 change in DDS.DataReaderProtocolStatus.received_gap_bytes since the last time the status was read.

    rejected_sample_count: The number of times a sample is rejected because it cannot be accepted by a reliable DataReader.

    Samples rejected by a reliable DataReader will be NACKed, and they will have to be resent by the DataWriter if they are still available in the DataWriter queue.

    This counter will always be 0 when using DDS.BEST_EFFORT_RELIABILITY_QOS.

    rejected_sample_count_change: The change in DDS.DataReaderProtocolStatus.rejected_sample_count since the last time the status was read.

    This counter will always be 0 when using DDS.BEST_EFFORT_RELIABILITY_QOS.

    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.

    Out_Of_Range_Rejected_Sample_Count: The number of samples dropped by the DataReader due to received window is full and the sample is out-of-order.

    When using DDS.RELIABLE_RELIABILITY_QOS; if the DataReader received samples out-of-order, they are stored internally until the missing samples are received. The number of out-of-order samples that the DataReader can keep is set by DDS.RtpsReliableReaderProtocol_t.receive_window_size. When the received window is full any out-of-order sample received will be dropped.

    received_fragment_count: The number of DATA_FRAG messages that have been received by this DataReader.

    This statistic is incremented upon the receipt of each DATA_FRAG message. Fragments from duplicate samples do not count towards this statistic. Applicable only when data is fragmented.

    Dropped_Fragment_Count: The number of DATA_FRAG messages that have been dropped by a DataReader.

    This statistic does not include malformed fragments. Applicable only when data is fragmented.

    Reassembled_Sample_Count: The number of fragmented samples that have been reassembled by a DataReader.

    This statistic is incremented when all of the fragments which are required to reassemble an entire sample have been received. Applicable only when data is fragmented.

    Sent_Nack_Fragment_Count: The number of NACK fragments that have been sent from a DataReader to a DataWriter.

    NACK FRAG RTPS messages are sent when large data is used in conjunction with reliable communication. They have the same properties as NACK messages, but instead of applying to samples, they apply to fragments. Applicable only when data is fragmented.

    Sent_Nack_Fragment_Bytes: The number of NACK fragment bytes that have been sent from a DataReader to a DataWriter.

    NACK FRAG RTPS messages are sent when large data is used in conjunction with reliable communication. They have the same properties as NACK messages, but instead of applying to samples, they apply to fragments. Applicable only when data is fragmented.

  • 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.ndds_osapi_osapi_hash_h.RTIOsapiHash;
          Sample_Signature                                            : aliased access RTIDDS.Low_Level.ndds_pres_pres_common_impl_h.PRESSampleSignature;
          Encapsulation_Id                                            : aliased EncapsulationId_T;
          Related_Epoch                                               : aliased SequenceNumber_T;
          Coherent_Set_Info                                           : aliased access RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_CoherentSetInfo_t;
       end record with Convention => C;

    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;

    LogCategory

    type LogCategory is private;

    Summary: Categories of logged messages.

    The NDDSConfigLogger.get_verbosity_by_category and NDDSConfigLogger.set_verbosity_by_category can be used to specify different verbosities for different categories of messages.

    LogVerbosity

    type LogVerbosity is private;

    Summary: The verbosities at which RTI Connext diagnostic information is logged.

    LogPrintFormat

    type LogPrintFormat is private;

    Summary: The format used to output RTI Connext diagnostic information.

    LoggingQosPolicy

    type LoggingQosPolicy is record
          Verbosity           : LogVerbosity   := VERBOSITY_SILENT;
          Category            : LogCategory    := Category_PLATFORM;
          Print_Format        : LogPrintFormat := PRINT_NONE;
          Output_File         : String;
          Output_File_Suffix  : String;
          Max_Bytes_Per_File  : Long := -1;
          Max_Files           : Long := -1;
       end record;
    ---------------------------------------------------------- SqlFilterAlignmentQos ----------------------------------------------------------

    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 with Convention => C_Pass_By_Copy;

    SqlFilterMemoryManagementQos

    type SqlFilterMemoryManagementQos is record
          Buffer_Min_Size : aliased DDS.Long := 0;
          Trim_Buffer     : aliased DDS.Boolean := False;
       end record with Convention => C_Pass_By_Copy;

    SqlFilterGeneratorQos

    type SqlFilterGeneratorQos is new RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h.DDS_SqlFilterGeneratorQos;

    MonitoringDedicatedParticipantSettings

    type MonitoringDedicatedParticipantSettings is record
          enable                       : aliased Boolean := False;
          domain_id                    : aliased Integer := 0;
          participant_qos_profile_name : aliased String;
          collector_initial_peers      : aliased String_Seq.Sequence;
       end record
       with Convention => C;
    ------------------------------------------------------------------------- Monitoring -------------------------------------------------------------------------

    MonitoringEventDistributionSettings

    type MonitoringEventDistributionSettings is record
          concurrency_level           : aliased Unsigned_Long;
          datawriter_qos_profile_name : aliased String;
          thread                      : aliased ThreadSettings_T;
          publication_period          : aliased Duration_T;
       end record
         with Convention => C;

    MonitoringPeriodicDistributionSettings

    type MonitoringPeriodicDistributionSettings is record
          datawriter_qos_profile_name : aliased String;
          thread                      : aliased ThreadSettings_T;
          polling_period              : aliased Duration_T;
       end record
         with Convention => C;

    MonitoringLoggingDistributionSettings

    type MonitoringLoggingDistributionSettings is record
          concurrency_level           : aliased Unsigned_Long;
          max_historical_logs         : aliased Unsigned_Long;
          datawriter_qos_profile_name : aliased String;
          thread                      : aliased ThreadSettings_T;
          publication_period          : aliased Duration_T;
       end record
         with Convention => C;

    MonitoringDistributionSettings

    type MonitoringDistributionSettings is record
          Dedicated_Participant      : aliased MonitoringDedicatedParticipantSettings;
          publisher_qos_profile_name : aliased String;
          event_settings             : aliased MonitoringEventDistributionSettings;
          periodic_settings          : aliased MonitoringPeriodicDistributionSettings;
          logging_settings           : aliased MonitoringLoggingDistributionSettings;
       end record
         with Convention => C;

    MonitoringMetricSelection

    type MonitoringMetricSelection is record
          resource_selection            : aliased String;
          enabled_metrics_selection     : aliased String_Seq.Sequence;
          disabled_metrics_selection    : aliased String_Seq.Sequence;
       end record
         with Convention => C;

    MonitoringMetricSelection_Access

    type MonitoringMetricSelection_Access is access all MonitoringMetricSelection;

    MonitoringMetricSelection_Array

    type MonitoringMetricSelection_Array is array
         (Natural range <>) of aliased MonitoringMetricSelection;

    MonitoringLoggingForwardingSettings

    type MonitoringLoggingForwardingSettings is record
          middleware_forwarding_level   : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
          security_forwarding_level     : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
          service_forwarding_level      : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
          user_forwarding_level         : aliased RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_Config_SyslogVerbosity := RTIDDS.Low_Level.ndds_ndds_config_common_h.NDDS_CONFIG_SYSLOG_VERBOSITY_WARNING;
       end record
         with Convention => C;

    MonitoringTelemetryData

    type MonitoringTelemetryData is record
          logs     : aliased MonitoringMetricSelection_Seq.Sequence;
          metrics  : aliased MonitoringLoggingForwardingSettings;
       end record
         with Convention => C;

    MonitoringQosPolicy

    type MonitoringQosPolicy is record
          enable                : aliased Boolean;
          application_name      : aliased String;
          distribution_settings : aliased MonitoringDistributionSettings;
          telemetry_data        : aliased MonitoringTelemetryData;
       end record
         with Convention => C;

    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.

    InvalidLocalIdentityAdvanceNoticeStatus

    type InvalidLocalIdentityAdvanceNoticeStatus is record
          Expiration_Time : aliased Time_T;
       end record with Convention => C;

    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 (String)

    Binding_Version : constant Standard.String := "7.2.0";

    INFINITE

    INFINITE : constant := -1;

    Null_Octets (Octets)

    Null_Octets : constant Octets := (0, System.Null_Address);

    NULL_STRING (String)

    NULL_STRING     : constant DDS.String := (Data => Interfaces.C.Strings.Null_Ptr);

    DOMAIN_ID_MAX

    DOMAIN_ID_MAX : constant := 250;

    Default_Domain (DomainId_T)

    Default_Domain  : constant DomainId_T := 0;

    Time_Zero (Time_T)

    Time_Zero       : constant Time_T := (0, 0);

    Summary: The default instant in time: zero seconds and zero nanoseconds

    TIME_INVALID_SEC (Long_Long)

    TIME_INVALID_SEC : constant Long_Long      := -1;

    Summary: A sentinel indicating an invalid second of time

    TIME_INVALID_NSEC (Unsigned_Long)

    TIME_INVALID_NSEC : constant Unsigned_Long      := 4_294_967_295;

    Summary: A sentinel indicating an invalid nano-second of time

    Time_Invalid (Time_T)

    Time_Invalid    : constant Time_T := (TIME_INVALID_SEC, TIME_INVALID_NSEC);

    Summary: A sentinel indicating an invalid time

    DURATION_ZERO_SEC (Long)

    DURATION_ZERO_SEC : constant Long := 0;

    Summary: A zero-length second period of time.

    DURATION_ZERO_NSEC (Unsigned_Long)

    DURATION_ZERO_NSEC : constant Unsigned_Long := 0;

    Summary: A zero-length nano-second period of time.

    DURATION_ZERO (Duration_T)

    Summary: A zero-length period of time.

    DURATION_INFINITE_SEC (Long)

    DURATION_INFINITE_SEC : constant Long := 2_147_483_647;

    Summary: An infinite second period of time.

    DURATION_INFINITE_NSEC (Unsigned_Long)

    DURATION_INFINITE_NSEC : constant Unsigned_Long := 4_294_967_295;

    Summary: An infinite nano-second period of time.

    DURATION_INFINITE (Duration_T)

    DURATION_INFINITE : constant Duration_T :=
                             (DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC);

    Summary: An infinite period of time.

    DURATION_AUTO_SEC (Long)

    DURATION_AUTO_SEC : constant Long := 2_1474_83_647;

    Summary: An auto second period of time.

    DURATION_AUTO_NSEC (Unsigned_Long)

    DURATION_AUTO_NSEC : constant Unsigned_Long := 0;

    Summary: An auto nano-second period of time.

    DURATION_AUTO (Duration_T)

    DURATION_AUTO     : constant Duration_T :=
                             (DURATION_AUTO_SEC, DURATION_AUTO_NSEC);

    Summary: Duration is automatically assigned.

    COMPRESSION_SETTINGS_T_DEFAULT (CompressionSettings_T)

    COMPRESSION_SETTINGS_T_DEFAULT : constant CompressionSettings_T := (others => <>);
    ------------------------------------------------- InstanceHandle_t -------------------------------------------------

    Null_InstanceHandle_T (InstanceHandle_T)

    Null_InstanceHandle_T : aliased constant InstanceHandle_T := InstanceHandle_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_HANDLE_NIL);

    HANDLE_NIL (InstanceHandle_T)

    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_T)

    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_T)

    GUID_UNKNOWN : Guid_T renames GUID_AUTO;

    Summary: Unknown GUID.

    SEQUENCE_NUMBER_UNKNOWN (SequenceNumber_T)

    SEQUENCE_NUMBER_UNKNOWN : constant  SequenceNumber_T := (High => -1, Low =>  16#FFFF_FFFF#);

    Summary: Unknown sequence number.

    SEQUENCE_NUMBER_ZERO (SequenceNumber_T)

    SEQUENCE_NUMBER_ZERO    : constant  SequenceNumber_T := (High =>  0, Low =>  0);

    Summary: Zero value for the sequence number.

    SEQUENCE_NUMBER_MAX (SequenceNumber_T)

    SEQUENCE_NUMBER_MAX     : constant  SequenceNumber_T := (High =>  2147483647, Low =>  16#FFFF_FFFF#);

    Summary: Highest, most positive value for the sequence number.

    AUTO_SEQUENCE_NUMBER (SequenceNumber_T)

    AUTO_SEQUENCE_NUMBER    : constant SequenceNumber_T := (High => -1, Low =>  16#FFFF_FFFF#);

    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. 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.

    NOT_ALLOWED_BY_SECURITY

    NOT_ALLOWED_BY_SECURITY : exception;

    Summary: An operation on the DDS API that fails because the security plugins do not allow it.

    An operation on the DDS API that fails because the security plugins do not allow it.

    INCONSISTENT_TOPIC_STATUS (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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 unacknowledged samples), the cache is 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 (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    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, such as the number of samples pushed, pulled, and filtered and the status of wire protocol traffic. Changes to this status information do not trigger a DDS.StatusCondition.

    DATA_READER_CACHE_STATUS (StatusKind)

    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 (StatusKind)

    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 (StatusKind)

    DATA_WRITER_DESTINATION_UNREACHABLE_STATUS : constant StatusKind :=
                                                      2#0100_0000_0000_0000_0000_0000_0000_0000#;

    DATA_WRITER_SAMPLE_REMOVED_STATUS (StatusKind)

    DATA_WRITER_SAMPLE_REMOVED_STATUS          : constant StatusKind :=
                                                      2#1000_0000_0000_0000_0000_0000_0000_0000#;

    STATUS_MASK_NONE (StatusMask)

    STATUS_MASK_NONE : constant StatusMask := 2#0000_0000_0000_0000_0000_0000_0000_0000#;

    Summary: No bits are set.

    STATUS_MASK_ALL (StatusMask)

    STATUS_MASK_ALL  : constant StatusMask := 2#1111_1111_1111_1111_1111_1111_1111_1111#;

    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 (ThreadSettingsKindMask)

    THREAD_SETTINGS_KIND_MASK_DEFAULT          : constant ThreadSettingsKindMask :=
                                                      THREAD_SETTINGS_OPTION_DEFAULT;

    Summary: The mask of default thread options.

    THREAD_SETTINGS_CPU_NO_ROTATION (ThreadSettingsCpuRotationKind_T)

    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 (ThreadSettingsCpuRotationKind_T)

    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 (ThreadSettingsCpuRotationKind_T)

    THREAD_SETTINGS_CPU_ROTATION_DEFAULT       : constant ThreadSettingsCpuRotationKind_T :=
                                                      THREAD_SETTINGS_CPU_NO_ROTATION;

    QOS_POLICY_COUNT (Long)

    QOS_POLICY_COUNT : constant Long := 63;

    Summary: Number of QoS policies in DDS.QosPolicyId_t.

    INVALID_QOS_POLICY_ID (QosPolicyId_T)

    INVALID_QOS_POLICY_ID : constant QosPolicyId_T := 0;

    Summary: Identifier for an invalid QoS policy

    USERDATA_QOS_POLICY_ID (QosPolicyId_T)

    USERDATA_QOS_POLICY_ID : constant QosPolicyId_T := 1;

    Summary: Identifier for DDS.UserDataQosPolicy

    DURABILITY_QOS_POLICY_ID (QosPolicyId_T)

    DURABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 2;

    Summary: Identifier for DDS.DurabilityQosPolicy

    PRESENTATION_QOS_POLICY_ID (QosPolicyId_T)

    PRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 3;

    Summary: Identifier for DDS.PresentationQosPolicy

    DEADLINE_QOS_POLICY_ID (QosPolicyId_T)

    DEADLINE_QOS_POLICY_ID : constant QosPolicyId_T := 4;

    Summary: Identifier for DDS.DeadlineQosPolicy

    LATENCYBUDGET_QOS_POLICY_ID (QosPolicyId_T)

    LATENCYBUDGET_QOS_POLICY_ID : constant QosPolicyId_T := 5;

    Summary: Identifier for DDS.LatencyBudgetQosPolicy

    OWNERSHIP_QOS_POLICY_ID (QosPolicyId_T)

    OWNERSHIP_QOS_POLICY_ID : constant QosPolicyId_T := 6;

    Summary: Identifier for DDS.OwnershipQosPolicy

    OWNERSHIPSTRENGTH_QOS_POLICY_ID (QosPolicyId_T)

    OWNERSHIPSTRENGTH_QOS_POLICY_ID : constant QosPolicyId_T := 7;

    Summary: Identifier for DDS.OwnershipStrengthQosPolicy

    LIVELINESS_QOS_POLICY_ID (QosPolicyId_T)

    LIVELINESS_QOS_POLICY_ID : constant QosPolicyId_T := 8;

    Summary: Identifier for DDS.LivelinessQosPolicy

    TIMEBASEDFILTER_QOS_POLICY_ID (QosPolicyId_T)

    TIMEBASEDFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 9;

    Summary: Identifier for DDS.TimeBasedFilterQosPolicy

    PARTITION_QOS_POLICY_ID (QosPolicyId_T)

    PARTITION_QOS_POLICY_ID : constant QosPolicyId_T := 10;

    Summary: Identifier for DDS.PartitionQosPolicy

    RELIABILITY_QOS_POLICY_ID (QosPolicyId_T)

    RELIABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 11;

    Summary: Identifier for DDS.ReliabilityQosPolicy

    DESTINATIONORDER_QOS_POLICY_ID (QosPolicyId_T)

    DESTINATIONORDER_QOS_POLICY_ID : constant QosPolicyId_T := 12;

    Summary: Identifier for DDS.DestinationOrderQosPolicy

    HISTORY_QOS_POLICY_ID (QosPolicyId_T)

    HISTORY_QOS_POLICY_ID : constant QosPolicyId_T := 13;

    Summary: Identifier for DDS.HistoryQosPolicy

    RESOURCELIMITS_QOS_POLICY_ID (QosPolicyId_T)

    RESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 14;

    Summary: Identifier for DDS.ResourceLimitsQosPolicy

    ENTITYFACTORY_QOS_POLICY_ID (QosPolicyId_T)

    ENTITYFACTORY_QOS_POLICY_ID : constant QosPolicyId_T := 15;

    Summary: Identifier for DDS.EntityFactoryQosPolicy

    WRITERDATALIFECYCLE_QOS_POLICY_ID (QosPolicyId_T)

    WRITERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 16;

    Summary: Identifier for DDS.WriterDataLifecycleQosPolicy

    READERDATALIFECYCLE_QOS_POLICY_ID (QosPolicyId_T)

    READERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 17;

    Summary: Identifier for DDS.ReaderDataLifecycleQosPolicy

    TOPICDATA_QOS_POLICY_ID (QosPolicyId_T)

    TOPICDATA_QOS_POLICY_ID : constant QosPolicyId_T := 18;

    Summary: Identifier for DDS.TopicDataQosPolicy

    GROUPDATA_QOS_POLICY_ID (QosPolicyId_T)

    GROUPDATA_QOS_POLICY_ID : constant QosPolicyId_T := 19;

    Summary: Identifier for DDS.GroupDataQosPolicy

    TRANSPORTPRIORITY_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTPRIORITY_QOS_POLICY_ID : constant QosPolicyId_T := 20;

    Summary: Identifier for DDS.TransportPriorityQosPolicy

    LIFESPAN_QOS_POLICY_ID (QosPolicyId_T)

    LIFESPAN_QOS_POLICY_ID : constant QosPolicyId_T := 21;

    Summary: Identifier for DDS.LifespanQosPolicy

    DURABILITYSERVICE_QOS_POLICY_ID (QosPolicyId_T)

    DURABILITYSERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 22;

    Summary: Identifier for DDS.DurabilityServiceQosPolicy

    DATA_REPRESENTATION_QOS_POLICY_ID (QosPolicyId_T)

    DATA_REPRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 23;

    Summary: Identifier for DDS.DataRepresentationQosPolicy

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID (QosPolicyId_T)

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID : constant QosPolicyId_T := 24;

    DATATAG_QOS_POLICY_ID (QosPolicyId_T)

    DATATAG_QOS_POLICY_ID : constant QosPolicyId_T := 25;

    Summary: Identifier for DDS.DataTagQosPolicy

    WIREPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    WIREPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1000;

    Summary: <<ext>> Identifier for DDS.WireProtocolQosPolicy

    DISCOVERY_QOS_POLICY_ID (QosPolicyId_T)

    DISCOVERY_QOS_POLICY_ID : constant QosPolicyId_T := 1001;

    Summary: <<ext>> Identifier for DDS.DiscoveryQosPolicy

    DATAREADERRESOURCELIMITS_QOS_POLICY_ID (QosPolicyId_T)

    DATAREADERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1003;

    Summary: <<ext>> Identifier for DDS.DataReaderResourceLimitsQosPolicy

    DATAWRITERRESOURCELIMITS_QOS_POLICY_ID (QosPolicyId_T)

    DATAWRITERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1004;

    Summary: <<ext>> Identifier for DDS.DataWriterResourceLimitsQosPolicy

    DATAREADERPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    DATAREADERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1005;

    Summary: <<ext>> Identifier for DDS.DataReaderProtocolQosPolicy

    DATAWRITERPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    DATAWRITERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1006;

    Summary: <<ext>> Identifier for DDS.DataWriterProtocolQosPolicy

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID (QosPolicyId_T)

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1007;

    Summary: <<ext>> Identifier for DDS.DomainParticipantResourceLimitsQosPolicy

    EVENT_QOS_POLICY_ID (QosPolicyId_T)

    EVENT_QOS_POLICY_ID : constant QosPolicyId_T := 1008;

    Summary: <<ext>> Identifier for DDS.EventQosPolicy

    DATABASE_QOS_POLICY_ID (QosPolicyId_T)

    DATABASE_QOS_POLICY_ID : constant QosPolicyId_T := 1009;

    Summary: <<ext>> Identifier for DDS.DatabaseQosPolicy

    RECEIVERPOOL_QOS_POLICY_ID (QosPolicyId_T)

    RECEIVERPOOL_QOS_POLICY_ID : constant QosPolicyId_T := 1010;

    Summary: <<ext>> Identifier for DDS.ReceiverPoolQosPolicy

    DISCOVERYCONFIG_QOS_POLICY_ID (QosPolicyId_T)

    DISCOVERYCONFIG_QOS_POLICY_ID : constant QosPolicyId_T := 1011;

    Summary: <<ext>> Identifier for DDS.DiscoveryConfigQosPolicy

    EXCLUSIVEAREA_QOS_POLICY_ID (QosPolicyId_T)

    EXCLUSIVEAREA_QOS_POLICY_ID : constant QosPolicyId_T := 1012;

    USEROBJECT_QOS_POLICY_ID (QosPolicyId_T)

    USEROBJECT_QOS_POLICY_ID : constant QosPolicyId_T := 1013;

    SYSTEMRESOURCELIMITS_QOS_POLICY_ID (QosPolicyId_T)

    SYSTEMRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1014;

    Summary: <<ext>> Identifier for DDS.SystemResourceLimitsQosPolicy

    TRANSPORTSELECTION_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTSELECTION_QOS_POLICY_ID : constant QosPolicyId_T := 1015;

    Summary: <<ext>> Identifier for DDS.TransportSelectionQosPolicy

    TRANSPORTUNICAST_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTUNICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1016;

    Summary: <<ext>> Identifier for DDS.TransportUnicastQosPolicy

    TRANSPORTMULTICAST_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTMULTICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1017;

    Summary: <<ext>> Identifier for DDS.TransportMulticastQosPolicy

    TRANSPORTBUILTIN_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTBUILTIN_QOS_POLICY_ID : constant QosPolicyId_T := 1018;

    Summary: <<ext>> Identifier for DDS.TransportBuiltinQosPolicy

    TYPESUPPORT_QOS_POLICY_ID (QosPolicyId_T)

    TYPESUPPORT_QOS_POLICY_ID : constant QosPolicyId_T := 1019;

    Summary: <<ext>> Identifier for DDS.TypeSupportQosPolicy

    PROPERTY_QOS_POLICY_ID (QosPolicyId_T)

    PROPERTY_QOS_POLICY_ID : constant QosPolicyId_T := 1020;

    Summary: <<ext>> Identifier for DDS.PropertyQosPolicy

    PUBLISHMODE_QOS_POLICY_ID (QosPolicyId_T)

    PUBLISHMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1021;

    Summary: <<ext>> Identifier for DDS.PublishModeQosPolicy

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID (QosPolicyId_T)

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID : constant QosPolicyId_T := 1022;

    Summary: <<ext>> Identifier for DDS.AsynchronousPublisherQosPolicy

    ENTITYNAME_QOS_POLICY_ID (QosPolicyId_T)

    ENTITYNAME_QOS_POLICY_ID : constant QosPolicyId_T := 1023;

    Summary: <<ext>> Identifier for DDS.EntityNameQosPolicy

    SERVICE_QOS_POLICY_ID (QosPolicyId_T)

    SERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 1025;

    BATCH_QOS_POLICY_ID (QosPolicyId_T)

    BATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1026;

    Summary: <<ext>> Identifier for DDS.BatchQosPolicy

    PROFILE_QOS_POLICY_ID (QosPolicyId_T)

    PROFILE_QOS_POLICY_ID : constant QosPolicyId_T := 1027;

    Summary: <<ext>> Identifier for DDS.ProfileQosPolicy

    LOCATORFILTER_QOS_POLICY_ID (QosPolicyId_T)

    LOCATORFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 1028;

    Summary: <<ext>> Identifier for DDS.LocatorFilterQosPolicy

    MULTICHANNEL_QOS_POLICY_ID (QosPolicyId_T)

    MULTICHANNEL_QOS_POLICY_ID : constant QosPolicyId_T := 1029;

    Summary: <<ext>> Identifier for DDS.MultiChannelQosPolicy

    TRANSPORTENCAPSULATION_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTENCAPSULATION_QOS_POLICY_ID : constant QosPolicyId_T := 1030;

    PUBLISHERPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    PUBLISHERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1031;

    SUBSCRIBERPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    SUBSCRIBERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1032;

    TOPICPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    TOPICPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1033;

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID (QosPolicyId_T)

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1034;

    AVAILABILITY_QOS_POLICY_ID (QosPolicyId_T)

    AVAILABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 1035;

    Summary: <<ext>> Identifier for DDS.AvailabilityQosPolicy

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID (QosPolicyId_T)

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID : constant QosPolicyId_T := 1036;
    QosPolicyId_t_TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID -- documentation removed in ifdoc

    LOGGING_QOS_POLICY_ID (QosPolicyId_T)

    LOGGING_QOS_POLICY_ID : constant QosPolicyId_T := 1037;

    Summary: <<ext>> Identifier for DDS.LoggingQosPolicy

    TOPICQUERYDISPATCH_QOS_POLICY_ID (QosPolicyId_T)

    TOPICQUERYDISPATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1038;

    Summary: <<ext>> Identifier for DDS.TopicQueryDispatchQosPolicy

    DATAWRITERTRANSFERMODE_QOS_POLICY_ID (QosPolicyId_T)

    DATAWRITERTRANSFERMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1039;

    Summary: <<ext>> Identifier for DDS.DataWriterTransferModeQosPolicy

    USERDATA_QOS_POLICY_NAME (String)

    USERDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserData");

    Summary: Stringified human-readable name for DDS.UserDataQosPolicy

    TOPICDATA_QOS_POLICY_NAME (String)

    TOPICDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicData");

    Summary: Stringified human-readable name for DDS.TopicDataQosPolicy

    GROUPDATA_QOS_POLICY_NAME (String)

    GROUPDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("GroupData");

    Summary: Stringified human-readable name for DDS.GroupDataQosPolicy

    TOPICPROTOCOL_QOS_POLICY_NAME (String)

    TOPICPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicProtocol");

    TOPIC_PROTOCOL_QOS_POLICY_DEFAULT (TopicProtocolQosPolicy)

    TOPIC_PROTOCOL_QOS_POLICY_DEFAULT : constant TopicProtocolQosPolicy :=
                                             (Vendor_Specific_Entity => False);

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME (String)

    DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantProtocol");

    DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT (DomainParticipantProtocolQosPolicy)

    DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT : constant DomainParticipantProtocolQosPolicy :=
                                                          (Vendor_Specific_Entity => False);

    BUFFER_POOL_UNLIMITED

    BUFFER_POOL_UNLIMITED : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_UNLIMITED;

    BUFFER_POOL_AUTO

    BUFFER_POOL_AUTO : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_AUTO;

    BUFFER_POOL_BUFFER_SIZE_AUTO

    BUFFER_POOL_BUFFER_SIZE_AUTO : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_BUFFER_SIZE_AUTO;

    AllocationSettings_T_AUTO (AllocationSettings_T)

    AllocationSettings_T_AUTO : constant AllocationSettings_T := (others => <>);

    DURABILITY_QOS_POLICY_NAME (String)

    DURABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Durability");

    Summary: Stringified human-readable name for DDS.DurabilityQosPolicy

    VOLATILE_DURABILITY_QOS (DurabilityQosPolicyKind)

    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 (DurabilityQosPolicyKind)

    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 (DurabilityQosPolicyKind)

    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 (DurabilityQosPolicyKind)

    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.

    DELETE_PERSISTENT_JOURNAL (PersistentJournalKind)

    DELETE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 0;

    Summary: Deletes the rollback journal at the conclusion of each transaction.

    TRUNCATE_PERSISTENT_JOURNAL (PersistentJournalKind)

    TRUNCATE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 1;

    Summary: Commits transactions by truncating the rollback journal to zero-length instead of deleting it.

    PERSIST_PERSISTENT_JOURNAL (PersistentJournalKind)

    PERSIST_PERSISTENT_JOURNAL : constant PersistentJournalKind := 2;

    Summary: Prevents the rollback journal from being deleted at the end of each transaction. Instead, the header of the journal is overwritten with zeros.

    MEMORY_PERSISTENT_JOURNAL (PersistentJournalKind)

    MEMORY_PERSISTENT_JOURNAL : constant PersistentJournalKind := 3;

    Summary: Stores the rollback journal in volatile RAM. This saves disk I/O.

    WAL_PERSISTENT_JOURNAL (PersistentJournalKind)

    WAL_PERSISTENT_JOURNAL : constant PersistentJournalKind := 4;

    Summary: Uses a write-ahead log instead of a rollback journal to implement transactions.

    OFF_PERSISTENT_JOURNAL (PersistentJournalKind)

    OFF_PERSISTENT_JOURNAL : constant PersistentJournalKind := 5;

    Summary: Completely disables the rollback journal. If the application crashes in the middle of a transaction when the OFF journaling mode is set, the persistent storage will very likely be corrupted.

    NORMAL_PERSISTENT_SYNCHRONIZATION (PersistentSynchronizationKind)

    NORMAL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 0;

    FULL_PERSISTENT_SYNCHRONIZATION (PersistentSynchronizationKind)

    FULL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 1;

    OFF_PERSISTENT_SYNCHRONIZATION (PersistentSynchronizationKind)

    OFF_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 2;

    PERSISTENT_STORAGE_SETTINGS_DEFAULT (PersistentStorageSettings)

    PERSISTENT_STORAGE_SETTINGS_DEFAULT : constant PersistentStorageSettings := (others => <>);

    DURABILITY_QOS_POLICY_DEFAULT (DurabilityQosPolicy)

    DURABILITY_QOS_POLICY_DEFAULT : constant DurabilityQosPolicy := (others => <>);

    PRESENTATION_QOS_POLICY_NAME (String)

    PRESENTATION_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("Presentation");

    Summary: Stringified human-readable name for DDS.PresentationQosPolicy

    INSTANCE_PRESENTATION_QOS (PresentationQosPolicyAccessScopeKind)

    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 (PresentationQosPolicyAccessScopeKind)

    TOPIC_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 1;

    Summary: Scope spans all instances within the same DDS.DataWriter, but not across instances in different DDS.DataWriter entities.

    GROUP_PRESENTATION_QOS (PresentationQosPolicyAccessScopeKind)

    GROUP_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 2;

    Summary: Scope spans all instances belonging to DDS.DataWriter entities within the same DDS.Publisher.

    HIGHEST_OFFERED_PRESENTATION_QOS (PresentationQosPolicyAccessScopeKind)

    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 (PresentationQosPolicy)

    PRESENTATION_QOS_POLICY_DEFAULT : constant PresentationQosPolicy := (others => <>);

    DEADLINE_QOS_POLICY_NAME (String)

    DEADLINE_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("Deadline");

    Summary: Stringified human-readable name for DDS.DeadlineQosPolicy

    DEADLINE_QOS_POLICY_DEFAULT (DeadlineQosPolicy)

    DEADLINE_QOS_POLICY_DEFAULT : constant DeadlineQosPolicy :=
                                       (Period => DURATION_INFINITE);

    LATENCYBUDGET_QOS_POLICY_NAME (String)

    LATENCYBUDGET_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LatencyBudget");

    Summary: Stringified human-readable name for DDS.LatencyBudgetQosPolicy

    LATENCY_BUDGET_QOS_POLICY_DEFAULT (LatencyBudgetQosPolicy)

    LATENCY_BUDGET_QOS_POLICY_DEFAULT : constant LatencyBudgetQosPolicy := (others => <>);

    OWNERSHIP_QOS_POLICY_NAME (String)

    OWNERSHIP_QOS_POLICY_NAME         : constant DDS.String := To_DDS_String ("Ownership");

    Summary: Stringified human-readable name for DDS.OwnershipQosPolicy

    SHARED_OWNERSHIP_QOS (OwnershipQosPolicyKind)

    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 (OwnershipQosPolicyKind)

    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 (OwnershipQosPolicy)

    OWNERSHIP_QOS_POLICY_DEFAULT : constant OwnershipQosPolicy := (others => <>);

    OWNERSHIPSTRENGTH_QOS_POLICY_NAME (String)

    OWNERSHIPSTRENGTH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("OwnershipStrength");

    Summary: Stringified human-readable name for DDS.OwnershipStrengthQosPolicy

    OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT (OwnershipStrengthQosPolicy)

    OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT : constant OwnershipStrengthQosPolicy :=
                                                 (Value => 0);

    LIVELINESS_QOS_POLICY_NAME (String)

    LIVELINESS_QOS_POLICY_NAME            : constant DDS.String := To_DDS_String ("Liveliness");

    Summary: Stringified human-readable name for DDS.LivelinessQosPolicy

    AUTOMATIC_LIVELINESS_QOS (LivelinessQosPolicyKind)

    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 (LivelinessQosPolicyKind)

    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 (LivelinessQosPolicyKind)

    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 (LivelinessQosPolicy)

    LIVELINESS_QOS_POLICY_DEFAULT : constant LivelinessQosPolicy := (others => <>);

    TIMEBASEDFILTER_QOS_POLICY_NAME (String)

    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 (TimeBasedFilterQosPolicy)

    TIME_BASED_FILTER_QOS_POLICY_DEFAULT : constant  TimeBasedFilterQosPolicy := (others => <>);

    PARTITION_QOS_POLICY_NAME (String)

    PARTITION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Partition");

    Summary: Stringified human-readable name for DDS.PartitionQosPolicy

    RELIABILITY_QOS_POLICY_NAME (String)

    RELIABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Reliability");

    Summary: Stringified human-readable name for DDS.ReliabilityQosPolicy

    BEST_EFFORT_RELIABILITY_QOS (ReliabilityQosPolicyKind)

    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 (ReliabilityQosPolicyKind)

    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 (ReliabilityQosPolicyAcknowledgmentModeKind)

    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 (ReliabilityQosPolicyAcknowledgmentModeKind)

    APPICATION_AUTO_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 1;

    Summary: Samples are acknowledged automatically after a subscribing application has accessed them.

    A sample received by a FooDataReader is acknowledged after the subscribing application accesses it, either through calling FooDataReader.take or FooDataReader.read on the DDS sample. If the read or take operation loans the samples, the acknowledgment is done after FooDataReader.return_loan is called. Otherwise, for read or take operations that make a copy, acknowledgment is done after the read or take operations are executed.

    APPICATION_ORDERED_ACKNOWLEDGMENT_MODE (ReliabilityQosPolicyAcknowledgmentModeKind)

    APPICATION_ORDERED_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 2;

    APPICATION_EXPLICIT_ACKNOWLEDGMENT_MODE (ReliabilityQosPolicyAcknowledgmentModeKind)

    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 (ReliabilityQosPolicy)

    RELIABILITY_QOS_POLICY_DEFAULT : constant ReliabilityQosPolicy := (others => <>);

    DESTINATIONORDER_QOS_POLICY_NAME (String)

    DESTINATIONORDER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DestinationOrder");

    Summary: Stringified human-readable name for DDS.DestinationOrderQosPolicy

    BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS (DestinationOrderQosPolicyKind)

    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 guarantee 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 (DestinationOrderQosPolicyKind)

    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.

    INSTANCE_SCOPE_DESTINATIONORDER_QOS (DestinationOrderQosPolicyScopeKind)

    INSTANCE_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 0;

    TOPIC_SCOPE_DESTINATIONORDER_QOS (DestinationOrderQosPolicyScopeKind)

    TOPIC_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 1;

    DESTINATION_ORDER_QOS_POLICY_DEFAULT (DestinationOrderQosPolicy)

    DESTINATION_ORDER_QOS_POLICY_DEFAULT : constant DestinationOrderQosPolicy := (others => <>);

    HISTORY_QOS_POLICY_NAME (String)

    HISTORY_QOS_POLICY_NAME              : constant DDS.String := To_DDS_String ("History");

    Summary: Stringified human-readable name for DDS.HistoryQosPolicy

    KEEP_LAST_HISTORY_QOS (HistoryQosPolicyKind)

    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 representing a disposal or unregistration of an instance count towards the depth and may replace other DDS samples currently in the DataWriter queue for the same instance.

    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 representing a disposal or unregistration of an instance do not count towards the history depth and will not replace other DDS samples currently in the DataReader queue for the same instance.

    KEEP_ALL_HISTORY_QOS (HistoryQosPolicyKind)

    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.

    HISTORY_QOS_POLICY_DEFAULT (HistoryQosPolicy)

    HISTORY_QOS_POLICY_DEFAULT           : constant HistoryQosPolicy := (others => <>);

    LENGTH_UNLIMITED (Long)

    LENGTH_UNLIMITED                     : constant Long  := -1;

    Summary: A special value indicating an unlimited quantity.

    DURABILITYSERVICE_QOS_POLICY_NAME (String)

    DURABILITYSERVICE_QOS_POLICY_NAME    : constant DDS.String := To_DDS_String ("DurabilityService");

    Summary: Stringified human-readable name for DDS.DurabilityQosPolicy

    DURABILITY_SERVICE_QOS_POLICY_DEFAULT (DurabilityServiceQosPolicy)

    DURABILITY_SERVICE_QOS_POLICY_DEFAULT : constant DurabilityServiceQosPolicy := (others => <>);

    RESOURCELIMITS_QOS_POLICY_NAME (String)

    RESOURCELIMITS_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("ResourceLimits");

    Summary: Stringified human-readable name for DDS.ResourceLimitsQosPolicy

    RESOURCE_LIMITS_QOS_POLICY_DEFAULT (ResourceLimitsQosPolicy)

    RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant ResourceLimitsQosPolicy := (others => <>);

    TRANSPORTPRIORITY_QOS_POLICY_NAME (String)

    TRANSPORTPRIORITY_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("TransportPriority");

    Summary: Stringified human-readable name for DDS.TransportPriorityQosPolicy

    TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT (TransportPriorityQosPolicy)

    TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT : constant TransportPriorityQosPolicy := (others => <>);

    LIFESPAN_QOS_POLICY_NAME (String)

    LIFESPAN_QOS_POLICY_NAME              : constant DDS.String := To_DDS_String ("Lifespan");

    Summary: Stringified human-readable name for DDS.LifespanQosPolicy

    LIFESPAN_QOS_POLICY_DEFAULT (LifespanQosPolicy)

    LIFESPAN_QOS_POLICY_DEFAULT        : constant LifespanQosPolicy := (others => <>);

    WRITERDATALIFECYCLE_QOS_POLICY_NAME (String)

    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 (WriterDataLifecycleQosPolicy)

    WRITER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant WriterDataLifecycleQosPolicy := (others => <>);

    READERDATALIFECYCLE_QOS_POLICY_NAME (String)

    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 (ReaderDataLifecycleQosPolicy)

    READER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant ReaderDataLifecycleQosPolicy := (others => <>);

    ENTITYFACTORY_QOS_POLICY_NAME (String)

    ENTITYFACTORY_QOS_POLICY_NAME            : constant DDS.String := To_DDS_String ("EntityFactory");

    Summary: Stringified human-readable name for DDS.EntityFactoryQosPolicy.

    ENTITY_FACTORY_QOS_POLICY_DEFAULT (EntityFactoryQosPolicy)

    ENTITY_FACTORY_QOS_POLICY_DEFAULT  : constant EntityFactoryQosPolicy := (others => <>);

    RTPS_RELIABLE_READER_PROTOCOL_DEFAULT (RtpsReliableReaderProtocol_T)

    RTPS_RELIABLE_READER_PROTOCOL_DEFAULT : aliased constant RtpsReliableReaderProtocol_T := (others => <>);

    RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT (RtpsReliableReaderProtocol_T)

    RTPS_RELIABLE_READER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT :
       aliased  constant RtpsReliableReaderProtocol_T := (Max_Heartbeat_Response_Delay => (0, 0),
                                                          others                       => <>);

    RTPS_PARTICIPANT_MESSAGE_READER_DISCOVERY_CONFIG_DEFAULT (RtpsReliableReaderProtocol_T)

    RTPS_PARTICIPANT_MESSAGE_READER_DISCOVERY_CONFIG_DEFAULT :
       aliased constant RtpsReliableReaderProtocol_T := (Max_Heartbeat_Response_Delay => (0, 0),
                                                         others                       => <>);

    RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT (RtpsReliableWriterProtocol_T)

    RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT : constant RtpsReliableWriterProtocol_T := (others => <>);

    RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT (RtpsReliableWriterProtocol_T)

    RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT  :  constant RtpsReliableWriterProtocol_T := (others => <>);

    RTPS_PARTICIPANT_MESSAGE_WRITER_DISCOVERY_CONFIG_DEFAULT (RtpsReliableWriterProtocol_T)

    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,
                                                 Disable_Repair_Piggyback_Heartbeat                                 => False
                                                );

    TRANSPORT_MULTICAST_LOCATORS_DEFAULT (TransportMulticastSettings_T)

    TRANSPORT_MULTICAST_LOCATORS_DEFAULT : constant TransportMulticastSettings_T := (others => <>);

    TRANSPORT_MULTICAST_MAPPING_FUNCTION_DEFAULT (TransportMulticastMappingFunction_T)

    TRANSPORT_MULTICAST_MAPPING_FUNCTION_DEFAULT : constant TransportMulticastMappingFunction_T := (others => <>);

    TRANSPORT_MULTICAST_MAPPING_DEFAULT (TransportMulticastMapping_T)

    TRANSPORT_MULTICAST_MAPPING_DEFAULT : constant TransportMulticastMapping_T := (others => <>);

    ENCAPSULATION_ID_CDR_BE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR_BE : constant EncapsulationId_T := 0;

    ENCAPSULATION_ID_CDR_LE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR_LE : constant EncapsulationId_T := 1;

    ENCAPSULATION_ID_CDR_NATIVE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);

    ENCAPSULATION_ID_CDR2_BE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR2_BE : constant EncapsulationId_T := 0;

    ENCAPSULATION_ID_CDR2_LE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR2_LE : constant EncapsulationId_T := 1;

    ENCAPSULATION_ID_CDR2_NATIVE (EncapsulationId_T)

    ENCAPSULATION_ID_CDR2_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);

    ENCAPSULATION_ID_SHMEM_REF_PLAIN (EncapsulationId_T)

    ENCAPSULATION_ID_SHMEM_REF_PLAIN : EncapsulationId_T := 16#C000#;

    ENCAPSULATION_ID_SHMEM_REF_FLAT_DATA (EncapsulationId_T)

    ENCAPSULATION_ID_SHMEM_REF_FLAT_DATA : EncapsulationId_T := 16#C001#;

    XCDR_DATA_REPRESENTATION (DataRepresentationId_T)

    XCDR_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
                                    DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR_DATA_REPRESENTATION);

    XML_DATA_REPRESENTATION (DataRepresentationId_T)

    XML_DATA_REPRESENTATION  : aliased constant DataRepresentationId_T :=
                                    DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XML_DATA_REPRESENTATION);

    XCDR2_DATA_REPRESENTATION (DataRepresentationId_T)

    XCDR2_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
                                     DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR2_DATA_REPRESENTATION);

    AUTO_DATA_REPRESENTATION (DataRepresentationId_T)

    AUTO_DATA_REPRESENTATION : aliased constant DataRepresentationId_T :=
                                    DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR2_DATA_REPRESENTATION);

    TRANSPORTSELECTION_QOS_POLICY_NAME (String)

    TRANSPORTSELECTION_QOS_POLICY_NAME : constant DDS.String  := To_DDS_String ("TransportSelection");

    Summary: Stringified human-readable name for DDS.TransportSelectionQosPolicy

    TRANSPORT_SELECTION_QOS_POLICY_DEFAULT (TransportSelectionQosPolicy)

    TRANSPORT_SELECTION_QOS_POLICY_DEFAULT : constant TransportSelectionQosPolicy := (others => <>);

    TRANSPORTUNICAST_QOS_POLICY_NAME (String)

    TRANSPORTUNICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportUnicast");

    Summary: Stringified human-readable name for DDS.TransportUnicastQosPolicy

    TRANSPORT_UNICAST_QOS_POLICY_DEFAULT (TransportUnicastQosPolicy)

    TRANSPORT_UNICAST_QOS_POLICY_DEFAULT : constant TransportUnicastQosPolicy := (others => <>);

    TRANSPORTMULTICAST_QOS_POLICY_NAME (String)

    TRANSPORTMULTICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticast");

    Summary: Stringified human-readable name for DDS.TransportMulticastQosPolicy

    AUTOMATIC_TRANSPORT_MULTICAST_QOS (TransportMulticastQosPolicyKind)

    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 (TransportMulticastQosPolicyKind)

    UNICAST_ONLY_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 1;

    Summary: Selects a unicast-only mode

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME (String)

    TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticastMapping");

    Summary: Stringified human-readable name for DDS.TransportMulticastMappingQosPolicy

    TRANSPORTENCAPSULATION_QOS_POLICY_NAME (String)

    TRANSPORTENCAPSULATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportEncapsulation");

    DISCOVERY_QOS_POLICY_NAME (String)

    DISCOVERY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Discovery");

    Summary: Stringified human-readable name for DDS.DiscoveryQosPolicy

    DISCOVERY_QOS_POLICY_DEFAULT (DiscoveryQosPolicy)

    DISCOVERY_QOS_POLICY_DEFAULT : constant  DiscoveryQosPolicy := (others => <>);

    TRANSPORTBUILTIN_QOS_POLICY_NAME (String)

    TRANSPORTBUILTIN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportBuiltin");

    Summary: Stringified human-readable name for DDS.TransportBuiltinQosPolicy

    TRANSPORTBUILTIN_UDPv4 (TransportBuiltinKind)

    TRANSPORTBUILTIN_UDPv4 : constant TransportBuiltinKind := 2 ** 0;

    Summary: Built-in UDPv4 transport, NDDS_Transport_UDPv4_Plugin

    TRANSPORTBUILTIN_SHMEM (TransportBuiltinKind)

    TRANSPORTBUILTIN_SHMEM : constant TransportBuiltinKind := 2 ** 1;

    Summary: Built-in shared memory transport, NDDS_Transport_Shmem_Plugin

    TRANSPORTBUILTIN_INTRA (TransportBuiltinKind)

    TRANSPORTBUILTIN_INTRA : constant TransportBuiltinKind := 2 ** 2;

    TRANSPORTBUILTIN_UDPv6 (TransportBuiltinKind)

    TRANSPORTBUILTIN_UDPv6 : constant TransportBuiltinKind := 2 ** 3;

    Summary: Built-in UDPv6 transport, NDDS_Transport_UDPv6_Plugin

    TRANSPORTBUILTIN_INTRA_ALIAS (String)

    TRANSPORTBUILTIN_INTRA_ALIAS : constant DDS.String := To_DDS_String ("builtin.intra");

    TRANSPORTBUILTIN_SHMEM_ALIAS (String)

    TRANSPORTBUILTIN_SHMEM_ALIAS : constant DDS.String := To_DDS_String ("builtin.shmem");

    Summary: Alias name for the shared memory built-in transport: "builtin.shmem"

    TRANSPORTBUILTIN_UDPv4_ALIAS (String)

    TRANSPORTBUILTIN_UDPv4_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv4");

    Summary: Alias name for the UDPv4 built-in transport: "builtin.udpv4"

    TRANSPORTBUILTIN_UDPv6_ALIAS (String)

    TRANSPORTBUILTIN_UDPv6_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv");

    Summary: Alias name for the UDPv6 built-in transport: "builtin.udpv6"

    TRANSPORTBUILTIN_MASK_NONE (TransportBuiltinKindMask)

    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 (TransportBuiltinKindMask)

    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 (TransportBuiltinKindMask)

    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 (TransportBuiltinQosPolicy)

    TRANSPORT_BUILTIN_QOS_POLICY_DEFAULT : constant TransportBuiltinQosPolicy :=
                                                (Mask => TRANSPORTBUILTIN_MASK_DEFAULT);

    RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS (RtpsWellKnownPorts_T)

    RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T :=  (others => <>);

    INTEROPERABLE_RTPS_WELL_KNOWN_PORTS (RtpsWellKnownPorts_T)

    INTEROPERABLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T
         := (Domain_Id_Gain                =>  250,
             Builtin_Unicast_Port_Offset   =>  10,
             User_Unicast_Port_Offset      =>  11,
             others                        => <>);

    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 (RtpsWellKnownPorts_T)

    RTPS_WELL_KNOWN_PORTS_DEFAULT : constant RtpsWellKnownPorts_T := (others => <>);

    RTPS_RESERVED_PORT_BUILTIN_UNICAST (RtpsReservedPortKind)

    RTPS_RESERVED_PORT_BUILTIN_UNICAST   : constant RtpsReservedPortKind := 2#0001#;

    Summary: Select the metatraffic unicast port.

    RTPS_RESERVED_PORT_BUILTIN_MULTICAST (RtpsReservedPortKind)

    RTPS_RESERVED_PORT_BUILTIN_MULTICAST : constant RtpsReservedPortKind := 2#0010#;

    Summary: Select the metatraffic multicast port.

    RTPS_RESERVED_PORT_USER_UNICAST (RtpsReservedPortKind)

    RTPS_RESERVED_PORT_USER_UNICAST      : constant RtpsReservedPortKind := 2#0100#;

    Summary: Select the usertraffic unicast port.

    RTPS_RESERVED_PORT_USER_MULTICAST (RtpsReservedPortKind)

    RTPS_RESERVED_PORT_USER_MULTICAST    : constant RtpsReservedPortKind := 2#1000#;

    Summary: Select the usertraffic multicast port.

    RTPS_RESERVED_PORT_MASK_DEFAULT (RtpsReservedPortKindMask)

    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 (RtpsReservedPortKindMask)

    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 (RtpsReservedPortKindMask)

    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 (String)

    WIREPROTOCOL_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("WireProtocol");

    Summary: Stringified human-readable name for DDS.WireProtocolQosPolicy

    RTPS_AUTO_ID_FROM_IP (WireProtocolQosPolicyAutoKind)

    RTPS_AUTO_ID_FROM_IP : constant WireProtocolQosPolicyAutoKind := 0;

    Summary: Builds the GUID prefix using the IPv4 address and process ID.

    Uses the IPv4 address of the first up-and-running interface of the host machine and the process ID to build the GUID prefix.

    RTPS_AUTO_ID_FROM_MAC (WireProtocolQosPolicyAutoKind)

    RTPS_AUTO_ID_FROM_MAC : constant WireProtocolQosPolicyAutoKind := 1;

    Summary: Builds the GUID prefix using the MAC address and process ID.

    Uses the first 32 bits of the MAC address assigned to the first up-and-running interface and the process ID to build the GUID prefix.

    Note to Android Users: DDS_RTPS_AUTO_ID_FROM_MAC is not supported in recent versions of Android (6.0 and later).

    RTPS_AUTO_ID (Unsigned_Long)

    RTPS_AUTO_ID    : constant Unsigned_Long := 0;

    WIRE_PROTOCOL_QOS_POLICY_DEFAULT (WireProtocolQosPolicy)

    WIRE_PROTOCOL_QOS_POLICY_DEFAULT : constant WireProtocolQosPolicy := (others => <>);

    LOCATOR_ADDRESS_LENGTH_MAX (Unsigned_Long)

    LOCATOR_ADDRESS_LENGTH_MAX  : constant Unsigned_Long := 16;

    Summary: Declares length of address field in locator.

    LOCATOR_INVALID (Locator_T)

    LOCATOR_INVALID : constant Locator_T :=
                           (Kind           => -1,
                            Port           => 0,
                            Address        => (others => 00),
                            Encapsulations => EncapsulationId_Seq.DEFAULT_SEQUENCE);

    Summary: An invalid locator.

    LOCATOR_KIND_INVALID (Long)

    LOCATOR_KIND_INVALID : constant Long := -1;

    Summary: Locator of this kind is invalid.

    LOCATOR_PORT_INVALID (Unsigned_Long)

    LOCATOR_PORT_INVALID : constant Unsigned_Long := 0;

    Summary: An invalid port.

    LOCATOR_ADDRESS_INVALID (Locator_Address_Array_T)

    LOCATOR_ADDRESS_INVALID : constant Locator_Address_Array_T := (others => 0);

    Summary: An invalid address.

    LOCATOR_KIND_ANY (Long)

    LOCATOR_KIND_ANY : constant Long := 0;

    LOCATOR_KIND_UDPv4 (Long)

    LOCATOR_KIND_UDPv4 : constant Long := 1;

    Summary: A locator for a UDPv4 address.

    LOCATOR_KIND_SHMEM (Long)

    LOCATOR_KIND_SHMEM  : constant Long := 2;

    Summary: A locator for an address acessed via shared memory.

    LOCATOR_KIND_INTRA (Long)

    LOCATOR_KIND_INTRA  : constant Long := 3;

    LOCATOR_KIND_UDPv6 (Long)

    LOCATOR_KIND_UDPv6 : constant Long := 5;

    Summary: A locator for a UDPv6 address.

    LOCATOR_KIND_DTLS (Long)

    LOCATOR_KIND_DTLS : constant Long := 6;

    LOCATOR_KIND_WAN (Long)

    LOCATOR_KIND_WAN : constant Long := 7;

    LOCATOR_KIND_TCPV4_LAN (Long)

    LOCATOR_KIND_TCPV4_LAN : constant Long := 8;

    LOCATOR_KIND_TCPV4_WAN (Long)

    LOCATOR_KIND_TCPV4_WAN : constant Long := 9;

    LOCATOR_KIND_TLSV4_LAN (Long)

    LOCATOR_KIND_TLSV4_LAN : constant Long := 10;

    LOCATOR_KIND_TLSV4_WAN (Long)

    LOCATOR_KIND_TLSV4_WAN : constant Long := 11;

    LOCATOR_KIND_RESERVED (Long)

    LOCATOR_KIND_RESERVED : constant Long := 1000;

    Summary: Locator of this kind is reserved.

    PROTOCOL_VERSION_DEFAULT (ProtocolVersion_T)

    PROTOCOL_VERSION_DEFAULT : constant ProtocolVersion_T :=  (others => <>);

    PROTOCOLVERSION_1_0 (ProtocolVersion_T)

    PROTOCOLVERSION_1_0      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 0);

    Summary: The protocol version 1.0

    PROTOCOLVERSION_1_1 (ProtocolVersion_T)

    PROTOCOLVERSION_1_1      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 1);

    Summary: The protocol version 1.1

    PROTOCOLVERSION_1_2 (ProtocolVersion_T)

    PROTOCOLVERSION_1_2      : constant ProtocolVersion_T :=
                                    (Major => 1,
                                     Minor => 2);

    Summary: The protocol version 1.2

    PROTOCOLVERSION_2_0 (ProtocolVersion_T)

    PROTOCOLVERSION_2_0      : constant ProtocolVersion_T :=
                                    (Major => 2,
                                     Minor => 0);

    Summary: The protocol version 2.0

    PROTOCOLVERSION_2_1 (ProtocolVersion_T)

    PROTOCOLVERSION_2_1      : constant ProtocolVersion_T :=
                                    (Major => 2,
                                     Minor => 1);

    Summary: The protocol version 2.1

    PROTOCOLVERSION (ProtocolVersion_T)

    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 (VendorId_T)

    VENDOR_ID_DEFAULT : constant  VendorId_T := (VendorId => (0, 0));

    VENDORID_UNKNOWN (VendorId_T)

    VENDORID_UNKNOWN  : constant  VendorId_T := (VendorId => (0, 0));

    PRODUCTVERSION_UNKNOWN (ProductVersion_T)

    PRODUCTVERSION_UNKNOWN : constant ProductVersion_T := (others => <>);

    Summary: The value used when the product version is unknown.

    DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT (DataReaderResourceLimitsInstanceReplacementSettings)

    DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT : constant
         DataReaderResourceLimitsInstanceReplacementSettings :=  (others => <>);

    DATAREADERRESOURCELIMITS_QOS_POLICY_NAME (String)

    DATAREADERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderResourceLimits");

    Summary: Stringified human-readable name for DDS.DataReaderResourceLimitsQosPolicy

    AUTO_MAX_TOTAL_INSTANCES (Long)

    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 (DataReaderResourceLimitsQosPolicy)

    DATA_READER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT :   constant DataReaderResourceLimitsQosPolicy := (others => <>);

    DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME (String)

    DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME       : constant DDS.String := To_DDS_String ("DataWriterResourceLimits");

    Summary: Stringified human-readable name for DDS.DataWriterResourceLimitsQosPolicy

    UNREGISTERED_INSTANCE_REPLACEMENT (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsInstanceReplacementKind)

    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 (DataWriterResourceLimitsQosPolicy)

    DATA_WRITER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DataWriterResourceLimitsQosPolicy := (others => <>);

    SERVICE_QOS_POLICY_NAME (String)

    SERVICE_QOS_POLICY_NAME                        : constant DDS.String := To_DDS_String ("Service");

    NO_SERVICE_QOS (ServiceQosPolicyKind)

    NO_SERVICE_QOS : constant ServiceQosPolicyKind := 0;

    Summary: There is no service associated with the entity.

    PERSISTENCE_SERVICE_QOS (ServiceQosPolicyKind)

    PERSISTENCE_SERVICE_QOS : constant ServiceQosPolicyKind := 1;

    Summary: The entity is an entity created by RTI Persistence Service.

    QUEUING_SERVICE_QOS (ServiceQosPolicyKind)

    QUEUING_SERVICE_QOS : constant ServiceQosPolicyKind := 2;

    Summary: The entity is an entity created by RTI Queuing Service.

    ROUTING_SERVICE_QOS (ServiceQosPolicyKind)

    ROUTING_SERVICE_QOS : constant ServiceQosPolicyKind := 3;

    Summary: The entity is an entity created by RTI Routing Service.

    RECORDING_SERVICE_QOS (ServiceQosPolicyKind)

    RECORDING_SERVICE_QOS : constant ServiceQosPolicyKind := 4;

    Summary: The entity is an entity created by RTI Recording Service.

    REPLAY_SERVICE_QOS (ServiceQosPolicyKind)

    REPLAY_SERVICE_QOS : constant ServiceQosPolicyKind := 5;

    Summary: The entity is an entity created by RTI Replay Service.

    DATABASE_INTEGRATION_SERVICE_QOS (ServiceQosPolicyKind)

    DATABASE_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 6;

    Summary: The entity is an entity created by RTI Database Integration Service.

    DDS_WEB_INTEGRATION_SERVICE_QOS (ServiceQosPolicyKind)

    DDS_WEB_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 7;

    Summary: The entity is an entity created by RTI Web Integration Service.

    SERVICE_QOS_POLICY_DEFAULT (ServiceQosPolicy)

    SERVICE_QOS_POLICY_DEFAULT : constant ServiceQosPolicy := (others => <>);

    PUBLISHERPROTOCOL_QOS_POLICY_NAME (String)

    PUBLISHERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublisherProtocol");

    PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT (PublisherProtocolQosPolicy)

    PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT : constant PublisherProtocolQosPolicy :=
                                                 (Vendor_Specific_Entity => False);

    SUBSCRIBERPROTOCOL_QOS_POLICY_NAME (String)

    SUBSCRIBERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SubscriberProtocol");

    SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT (SubscriberProtocolQosPolicy)

    SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT : constant SubscriberProtocolQosPolicy :=
                                                  (Vendor_Specific_Entity => False);

    DATAREADERPROTOCOL_QOS_POLICY_NAME (String)

    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 (DataReaderProtocolQosPolicy)

    DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataReaderProtocolQosPolicy := (others => <>);

    DATAWRITERPROTOCOL_QOS_POLICY_NAME (String)

    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 (DataWriterProtocolQosPolicy)

    DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataWriterProtocolQosPolicy := (others => <>);

    SYSTEMRESOURCELIMITS_QOS_POLICY_NAME (String)

    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 (SystemResourceLimitsQosPolicy)

    SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant SystemResourceLimitsQosPolicy := (others => <>);

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME (String)

    DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME :  constant DDS.String := To_DDS_String ("DomainParticipantResourceLimits");

    Summary: Stringified human-readable name for DDS.DomainParticipantResourceLimitsQosPolicy

    DomainParticipantResourceLimitsQosPolicy_MATCH_INIT (Long)

    DomainParticipantResourceLimitsQosPolicy_MATCH_INIT : constant DDS.Long := 32;

    NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT (DomainParticipantResourceLimitsIgnoredEntityReplacementKind)

    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 (DomainParticipantResourceLimitsIgnoredEntityReplacementKind)

    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 (DomainParticipantResourceLimitsQosPolicy)

    DOMAIN_PARTICIPANT_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DomainParticipantResourceLimitsQosPolicy := (others => <>);

    EVENT_QOS_POLICY_NAME (String)

    EVENT_QOS_POLICY_NAME                                 : constant DDS.String := To_DDS_String ("Event");

    Summary: Stringified human-readable name for DDS.EventQosPolicy

    EVENT_QOS_POLICY_DEFAULT (EventQosPolicy)

    EVENT_QOS_POLICY_DEFAULT : constant EventQosPolicy := (others => <>);

    DATABASE_QOS_POLICY_NAME (String)

    DATABASE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Database");

    Summary: Stringified human-readable name for DDS.DatabaseQosPolicy

    DATABASE_QOS_POLICY_DEFAULT (DatabaseQosPolicy)

    DATABASE_QOS_POLICY_DEFAULT :  constant DatabaseQosPolicy := (others => <>);

    RECEIVERPOOL_QOS_POLICY_NAME (String)

    RECEIVERPOOL_QOS_POLICY_NAME : DDS.String := To_DDS_String ("ReceiverPool");

    Summary: Stringified human-readable name for DDS.ReceiverPoolQosPolicy

    ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT (Long)

    ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT : constant Long := -1;

    RECEIVER_POOL_QOS_POLICY_DEFAULT (ReceiverPoolQosPolicy)

    RECEIVER_POOL_QOS_POLICY_DEFAULT : constant ReceiverPoolQosPolicy := (others => <>);

    BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT (BuiltinTopicReaderResourceLimits_T)

    BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT : constant BuiltinTopicReaderResourceLimits_T := (others => <>);

    BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH

    BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH         : constant := 4;

    BuiltinTopicKey_T_INITIALIZER (BuiltinTopicKey_T)

    BuiltinTopicKey_T_INITIALIZER : constant BuiltinTopicKey_T :=
                                         (Value => (0, 0, 0, 0));

    PUBLISHMODE_QOS_POLICY_NAME (String)

    PUBLISHMODE_QOS_POLICY_NAME   : constant DDS.String := To_DDS_String ("PublishMode");

    Summary: Stringified human-readable name for DDS.PublishModeQosPolicy

    SYNCHRONOUS_PUBLISH_MODE_QOS (PublishModeQosPolicyKind)

    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 (PublishModeQosPolicyKind)

    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 (Long)

    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 (Long)

    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 (PublishModeQosPolicy)

    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 (String)

    DISCOVERYCONFIG_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DiscoveryConfig");

    Summary: Stringified human-readable name for DDS.DiscoveryConfigQosPolicy

    DISCOVERYCONFIG_BUILTIN_SPDP (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_SPDP  : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0001#;

    DISCOVERYCONFIG_BUILTIN_SEDP (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_SEDP  : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0010#;

    DISCOVERYCONFIG_BUILTIN_SDP (DiscoveryConfigBuiltinPluginKindMask)

    Summary: [default] Simple discovery plugin.

    It is equivalent to SPDP + SEDP.

    DISCOVERYCONFIG_BUILTIN_EDS (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_EDS   : constant  DiscoveryConfigBuiltinPluginKindMask := 2#0100#;

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL     :
       constant  DiscoveryConfigBuiltinPluginKindMask := 16#EFFF#;

    Summary: All bits are set.

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE    :
       constant  DiscoveryConfigBuiltinPluginKindMask := 0;

    Summary: No bits are set.

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT (DiscoveryConfigBuiltinPluginKindMask)

    DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT :
       constant  DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_SDP;

    Summary: The default value of DDS.DiscoveryConfigQosPolicy.builtin_discovery_plugins.

    DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY (DiscoveryPluginPromiscuityKind)

    DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 1;

    DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY (DiscoveryPluginPromiscuityKind)

    DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 16#FFFF#;

    LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE (RemoteParticipantPurgeKind)

    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 (RemoteParticipantPurgeKind)

    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 (DiscoveryBuiltinReaderFragmentationResourceLimits_T)

    DISCOVERY_BUILTIN_READER_FRAGMENTATION_RESOURCE_LIMITS_DEFAULT : constant DiscoveryBuiltinReaderFragmentationResourceLimits_T := (others => <>);

    TYPESUPPORT_QOS_POLICY_NAME (String)

    TYPESUPPORT_QOS_POLICY_NAME                                    : constant DDS.String := To_DDS_String ("TypeSupport");

    Summary: Stringified human-readable name for DDS.TypeSupportQosPolicy

    TYPESUPPORT_QOS_POLICY_DEFAULT (TypeSupportQosPolicy)

    TYPESUPPORT_QOS_POLICY_DEFAULT : constant TypeSupportQosPolicy :=
                                          (Plugin_Data      => System.Null_Address,
                                           Cdr_Padding_Kind => AUTO_CDR_PADDING);

    SEMAPHORE_BLOCKING_KIND (ThreadBlockingKind)

    SEMAPHORE_BLOCKING_KIND       : constant ThreadBlockingKind := 0;

    SPIN_BLOCKING_KIND (ThreadBlockingKind)

    SPIN_BLOCKING_KIND            : constant ThreadBlockingKind := 1;

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME (String)

    ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("AsynchronousPublisher");

    Summary: Stringified human-readable name for DDS.AsynchronousPublisherQosPolicy

    ASYNCHRONOUS_PUBLISHER_QOS_POLICY_DEFAULT (AsynchronousPublisherQosPolicy)

    ASYNCHRONOUS_PUBLISHER_QOS_POLICY_DEFAULT : constant AsynchronousPublisherQosPolicy := (others => <>);

    DISCOVERY_CONFIG_QOS_POLICY_DEFAULT (DiscoveryConfigQosPolicy)

    DISCOVERY_CONFIG_QOS_POLICY_DEFAULT : constant DiscoveryConfigQosPolicy := (others => <>);

    USEROBJECT_QOS_POLICY_NAME (String)

    USEROBJECT_QOS_POLICY_NAME    : constant DDS.String := To_DDS_String ("UserObject");

    USER_OBJECT_QOS_POLICY_DEFAULT (UserObjectQosPolicy)

    USER_OBJECT_QOS_POLICY_DEFAULT : constant UserObjectQosPolicy := (others => <>);

    EXCLUSIVEAREA_QOS_POLICY_NAME (String)

    EXCLUSIVEAREA_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("ExclusiveArea");

    EXCLUSIVE_AREA_AUTO_LEVEL (Long)

    EXCLUSIVE_AREA_AUTO_LEVEL     : constant DDS.Long := -1;

    EXCLUSIVE_AREA_QOS_POLICY_DEFAULT (ExclusiveAreaQosPolicy)

    EXCLUSIVE_AREA_QOS_POLICY_DEFAULT : constant ExclusiveAreaQosPolicy :=
                                             (Use_Shared_Exclusive_Area => False,
                                              Level                     => EXCLUSIVE_AREA_AUTO_LEVEL);

    DATAWRITERTRANSFERMODE_QOS_POLICY_NAME (String)

    DATAWRITERTRANSFERMODE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterTransferMode");

    Summary: Stringified human-readable name for DDS.DataWriterTransferModeQosPolicy

    DataWriterShmemRefTransferModeSettings_INITIALIZER (DataWriterShmemRefTransferModeSettings)

    DataWriterShmemRefTransferModeSettings_INITIALIZER : constant DataWriterShmemRefTransferModeSettings :=
                                                              (Enable_Data_Consistency_Check => True);

    DataWriterTransferModeQosPolicy_INITIALIZER (DataWriterTransferModeQosPolicy)

    DataWriterTransferModeQosPolicy_INITIALIZER : constant DataWriterTransferModeQosPolicy :=
                                                       (Shmem_Ref_Settings => DataWriterShmemRefTransferModeSettings_INITIALIZER);

    TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME (String)

    TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicQueryDispatch");

    Summary: Stringified human-readable name for DDS.TopicQueryDispatchQosPolicy

    TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT (TopicQueryDispatchQosPolicy)

    TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT : constant TopicQueryDispatchQosPolicy := (others => <>);

    BATCH_QOS_POLICY_NAME (String)

    BATCH_QOS_POLICY_NAME         : constant DDS.String := To_DDS_String ("Batch");

    Summary: Stringified human-readable name for DDS.BatchQosPolicy

    BATCH_QOS_POLICY_DEFAULT (BatchQosPolicy)

    BATCH_QOS_POLICY_DEFAULT      : constant BatchQosPolicy := (others => <>);

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME (String)

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeConsistencyEnforcement");

    Summary: Stringified human-readable name for DDS.TypeConsistencyEnforcementQosPolicy

    DISALLOW_TYPE_COERCION (TypeConsistencyKind)

    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 (TypeConsistencyKind)

    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.

    AUTO_TYPE_COERCION (TypeConsistencyKind)

    AUTO_TYPE_COERCION            : constant TypeConsistencyKind := 2;

    Summary: This AUTO value will be applied as DDS.DISALLOW_TYPE_COERCION when the data type is annotated with \@transfer_mode(SHMEM_REF) and the \@language_binding is PLAIN (default) while using C, Traditional C++, or Modern C++ APIs. In all other cases, this AUTO value will be applied as DDS.ALLOW_TYPE_COERCION.

    [default]

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT (TypeConsistencyEnforcementQosPolicy)

    TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT : constant TypeConsistencyEnforcementQosPolicy := (others => <>);

    LOCATORFILTER_QOS_POLICY_NAME (String)

    LOCATORFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LocatorFilter");

    Summary: Stringified human-readable name for DDS.LocatorFilterQosPolicy

    LOCATOR_FILTER_QOS_POLICY_DEFAULT (LocatorFilterQosPolicy)

    LOCATOR_FILTER_QOS_POLICY_DEFAULT : constant LocatorFilterQosPolicy := (others => <>);

    MULTICHANNEL_QOS_POLICY_NAME (String)

    MULTICHANNEL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("MultiChannel");

    Summary: Stringified human-readable name for DDS.MultiChannelQosPolicy

    PROPERTY_QOS_POLICY_NAME (String)

    PROPERTY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Property");

    Summary: Stringified human-readable name for DDS.PropertyQosPolicy.

    PROPERTY_QOS_POLICY_DEFAULT (PropertyQosPolicy)

    PROPERTY_QOS_POLICY_DEFAULT : constant PropertyQosPolicy :=
                                       (Value => Property_T_Seq.DEFAULT_SEQUENCE);

    AVAILABILITY_QOS_POLICY_NAME (String)

    AVAILABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Availability");

    Summary: Stringified human-readable name for DDS.AvailabilityQosPolicy

    CONTENT_FILTER_PROPERTY_DEFAULT (ContentFilterProperty_T)

    CONTENT_FILTER_PROPERTY_DEFAULT : constant ContentFilterProperty_T := (others => <>);

    ENTITYNAME_QOS_POLICY_NAME (String)

    ENTITYNAME_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityName");

    Summary: Stringified human-readable name for DDS.EntityNameQosPolicy

    ENTITY_NAME_QOS_POLICY_DEFAULT (EntityNameQosPolicy)

    ENTITY_NAME_QOS_POLICY_DEFAULT : constant EntityNameQosPolicy :=
                                          (Name      => (Data => DDS.NULL_STRING.Data),
                                           Role_Name => (Data => DDS.NULL_STRING.Data));

    LOGGING_QOS_POLICY_NAME (String)

    LOGGING_QOS_POLICY_NAME        : constant DDS.String := To_DDS_String ("Logging");

    Summary: Stringified human-readable name for DDS.LoggingQosPolicy

    PROFILE_QOS_POLICY_NAME (String)

    PROFILE_QOS_POLICY_NAME  : constant DDS.String := To_DDS_String ("Profile");

    Summary: Stringified human-readable name for DDS.ProfileQosPolicy

    AUTO_SAMPLE_IDENTITY (SampleIdentity_T)

    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 (SampleIdentity_T)

    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}

    NULL_SAMPLE_IDENTITY (SampleIdentity_T)

    NULL_SAMPLE_IDENTITY : constant SampleIdentity_T :=
                                (Writer_Guid     => GUID_UNKNOWN,
                                 Sequence_Number => SEQUENCE_NUMBER_ZERO);

    Summary: An invalid or unknown sample identity

    Special DDS_UNKNOWN_SAMPLE_IDENTITY value {DDS_GUID_UNKNOWN, DDS_SEQUENCE_NUMBER_UNKNOWN}

    COOKIE_DEFAULT (Cookie_T)

    COOKIE_DEFAULT : constant Cookie_T := (Value => Octet_Seq.DEFAULT_SEQUENCE);

    REDELIVERED_SAMPLE (SampleFlagBits)

    REDELIVERED_SAMPLE                 : constant SampleFlagBits := 2#0000_0001#;

    INTERMEDIATE_REPLY_SEQUENCE_SAMPLE (SampleFlagBits)

    INTERMEDIATE_REPLY_SEQUENCE_SAMPLE : constant SampleFlagBits := 2#0000_0010#;

    REPLICATE_SAMPLE (SampleFlagBits)

    REPLICATE_SAMPLE                   : constant SampleFlagBits := 2#0000_0100#;

    LAST_SHARED_READER_QUEUE_SAMPLE (SampleFlagBits)

    LAST_SHARED_READER_QUEUE_SAMPLE    : constant SampleFlagBits := 2#0000_1000#;

    INTERMEDIATE_TOPIC_QUERY_SAMPLE (SampleFlagBits)

    INTERMEDIATE_TOPIC_QUERY_SAMPLE    : constant SampleFlagBits := 2#0001_0000#;

    WRITER_REMOVED_BATCH_SAMPLE (SampleFlagBits)

    WRITER_REMOVED_BATCH_SAMPLE        : constant SampleFlagBits := 2#0010_0000#;

    DISCOVERY_SERVICE_SAMPLE (SampleFlagBits)

    DISCOVERY_SERVICE_SAMPLE           : constant SampleFlagBits := 2#0100_0000#;

    WRITEPARAMS_DEFAULT (WriteParams_T)

    WRITEPARAMS_DEFAULT : constant WriteParams_T := (others => <>);

    BUILTIN_TOPIC_MAX_STRING_LENGTH

    BUILTIN_TOPIC_MAX_STRING_LENGTH : constant := 256;

    PARTICIPANT_TOPIC_NAME (String)

    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

    PARTICIPANT_TRUSTED_TOPIC_NAME (String)

    PARTICIPANT_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantSecure");

    PARTICIPANT_MESSAGE_TOPIC_NAME (String)

    PARTICIPANT_MESSAGE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessage");

    PARTICIPANT_MESSAGE_TRUSTED_TOPIC_NAME (String)

    PARTICIPANT_MESSAGE_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessageSecure");

    PARTICIPANT_PROXY_TOPIC_NAME (String)

    PARTICIPANT_PROXY_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantProxy");

    PARTICIPANT_STATE_TOPIC_NAME (String)

    PARTICIPANT_STATE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantState");

    ParticipantBuiltinTopicData_TypeName (String)

    ParticipantBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PARTICIPANT_TYPE_NAME);

    ParticipantBuiltinTopicData_INITIALIZER (ParticipantBuiltinTopicData)

    ParticipantBuiltinTopicData_INITIALIZER : constant ParticipantBuiltinTopicData := (others => <>);

    TOPIC_TOPIC_NAME (String)

    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 (String)

    TopicBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_TOPIC_TYPE_NAME);

    TopicBuiltinTopicData_INITIALIZER (TopicBuiltinTopicData)

    TopicBuiltinTopicData_INITIALIZER : constant TopicBuiltinTopicData := (others => <>);

    PUBLICATION_TOPIC_NAME (String)

    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

    PUBLICATION_TRUSTED_TOPIC_NAME (String)

    PUBLICATION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublicationSecure");

    PublicationBuiltinTopicData_TypeName (String)

    PublicationBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PUBLICATION_TYPE_NAME);

    SUBSCRIPTION_TOPIC_NAME (String)

    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

    SUBSCRIPTION_TRUSTED_TOPIC_NAME (String)

    SUBSCRIPTION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscriptionSecure");

    SubscriptionBuiltinTopicData_TypeName (String)

    SubscriptionBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_SUBSCRIPTION_TYPE_NAME);

    InconsistentTopicStatus_INITIALIZER (InconsistentTopicStatus)

    InconsistentTopicStatus_INITIALIZER : constant InconsistentTopicStatus := (others => <>);

    OfferedDeadlineMissedStatus_INITIALIZER (OfferedDeadlineMissedStatus)

    OfferedDeadlineMissedStatus_INITIALIZER : constant OfferedDeadlineMissedStatus := (others => <>);

    LivelinessLostStatus_INITIALIZER (LivelinessLostStatus)

    LivelinessLostStatus_INITIALIZER : constant LivelinessLostStatus := (others => <>);

    OfferedIncompatibleQosStatus_INITIALIZER (OfferedIncompatibleQosStatus)

    OfferedIncompatibleQosStatus_INITIALIZER : constant OfferedIncompatibleQosStatus := (others => <>);

    PublicationMatchedStatus_INITIALIZER (PublicationMatchedStatus)

    PublicationMatchedStatus_INITIALIZER : constant PublicationMatchedStatus := (others => <>);

    ReliableWriterCacheEventCount_INITIALIZER (ReliableWriterCacheEventCount)

    ReliableWriterCacheEventCount_INITIALIZER : constant ReliableWriterCacheEventCount := (others => <>);

    ReliableWriterCacheChangedStatus_INITIALIZER (ReliableWriterCacheChangedStatus)

    ReliableWriterCacheChangedStatus_INITIALIZER : constant ReliableWriterCacheChangedStatus := (others => <>);

    ReliableReaderActivityChangedStatus_INITIALIZER (ReliableReaderActivityChangedStatus)

    ReliableReaderActivityChangedStatus_INITIALIZER : constant  ReliableReaderActivityChangedStatus := (others => <>);

    RequestedDeadlineMissedStatus_INITIALIZER (RequestedDeadlineMissedStatus)

    RequestedDeadlineMissedStatus_INITIALIZER : constant RequestedDeadlineMissedStatus := (others => <>);

    LivelinessChangedStatus_INITIALIZER (LivelinessChangedStatus)

    LivelinessChangedStatus_INITIALIZER : constant LivelinessChangedStatus := (others => <>);

    RequestedIncompatibleQosStatus_INITIALIZER (RequestedIncompatibleQosStatus)

    RequestedIncompatibleQosStatus_INITIALIZER : constant RequestedIncompatibleQosStatus := (others => <>);
    ---------------------------------------------------------- SampleLostStatusKind ----------------------------------------------------------

    NOT_LOST (SampleLostStatusKind)

    NOT_LOST                                   : constant SampleLostStatusKind := 0;

    Summary: The sample was not lost.

    This constant is an extension to the DDS standard.

    LOST_BY_WRITER (SampleLostStatusKind)

    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 (SampleLostStatusKind)

    LOST_BY_INSTANCES_LIMIT                    : constant SampleLostStatusKind := 2;

    Summary: A resource limit on the number of instances (DDS.ResourceLimitsQosPolicy.max_instances) was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.ResourceLimitsQosPolicy

    LOST_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT (SampleLostStatusKind)

    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 (DDS.DataReaderResourceLimitsQosPolicy.max_remote_writers_per_instance) was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_INCOMPLETE_COHERENT_SET (SampleLostStatusKind)

    LOST_BY_INCOMPLETE_COHERENT_SET            : constant SampleLostStatusKind := 4;

    Summary: A sample is lost because it is part of a large coherent set. A large coherent set is a coherent set that cannot fit all at once into the DDS.DataReader queue because resource limits are exceeded.

    For example, if DDS.ResourceLimitsQosPolicy.max_samples_per_instance on the DataReader is 10 and the coherent set has 15 samples for a given instance, the coherent set is a large coherent set that will be considered incomplete.

    The resource limits that can lead to large coherent sets are: DDS.ResourceLimitsQosPolicy.max_samples, DDS.ResourceLimitsQosPolicy.max_samples_per_instance, DDS.ResourceLimitsQosPolicy.max_instances, and DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer.

    This constant is an extension to the DDS standard.

    LOST_BY_LARGE_COHERENT_SET (SampleLostStatusKind)

    LOST_BY_LARGE_COHERENT_SET                 : constant SampleLostStatusKind := 5;

    Summary: A sample is lost because it is part of a large coherent set. A large coherent set is a coherent set that cannot fit all at once into the DDS.DataReader queue because resource limits are exceeded.

    For example, if DDS.ResourceLimitsQosPolicy.max_samples_per_instance on the DataReader is 10 and the coherent set has 15 samples for a given instance, the coherent set is a large coherent set that will be considered incomplete.

    The resource limits that can lead to large coherent sets are: DDS.ResourceLimitsQosPolicy.max_samples, DDS.ResourceLimitsQosPolicy.max_samples_per_instance, DDS.ResourceLimitsQosPolicy.max_instances, and DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer.

    This constant is an extension to the DDS standard.

    LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT (SampleLostStatusKind)

    LOST_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT    : constant SampleLostStatusKind := 6;

    Summary: When using DDS.BEST_EFFORT_RELIABILITY_QOS: a resource limit on the number of samples from a given remote writer that a DDS.DataReader may store (DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer) was reached. When using DDS.RELIABLE_RELIABILITY_QOS, reaching DDS.DataReaderResourceLimitsQosPolicy.max_samples_per_remote_writer will trigger a rejection, not a loss, with reason DDS.REJECTED_BY_SAMPLES_PER_REMOTE_WRITER_LIMIT.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_VIRTUAL_WRITERS_LIMIT (SampleLostStatusKind)

    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 (DDS.DataReaderResourceLimitsQosPolicy.max_remote_virtual_writers) was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_REMOTE_WRITERS_PER_SAMPLE_LIMIT (SampleLostStatusKind)

    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 (DDS.DataReaderResourceLimitsQosPolicy.max_remote_writers_per_sample) was reached.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_AVAILABILITY_WAITING_TIME (SampleLostStatusKind)

    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.AvailabilityQosPolicy

    LOST_BY_REMOTE_WRITER_SAMPLES_PER_VIRTUAL_QUEUE_LIMIT (SampleLostStatusKind)

    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 field is currently not used.)

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_OUT_OF_MEMORY (SampleLostStatusKind)

    LOST_BY_OUT_OF_MEMORY                      : constant SampleLostStatusKind := 11;

    LOST_BY_OUT_OF_MEMORY: A sample was lost because there was not enough memory to store the sample.

    This constant is an extension to the DDS standard.
    See also: DDS.DataReaderResourceLimitsQosPolicy

    LOST_BY_UNKNOWN_INSTANCE (SampleLostStatusKind)

    LOST_BY_UNKNOWN_INSTANCE                   : constant SampleLostStatusKind := 12;

    LOST_BY_UNKNOWN_INSTANCE: A received sample was lost because it doesn't contain enough information for the reader to know what instance it is associated with.

    This constant is an extension to the DDS standard.

    SampleLostStatus_INITIALIZER (SampleLostStatus)

    SampleLostStatus_INITIALIZER : constant SampleLostStatus := (others => <>);
    ---------------------------------------------------------- SampleRejectedStatus ----------------------------------------------------------

    SampleRejectedStatus_INITIALIZER (SampleRejectedStatus)

    SampleRejectedStatus_INITIALIZER : constant SampleRejectedStatus := (others => <>);

    SubscriptionMatchedStatus_INITIALIZER (SubscriptionMatchedStatus)

    SubscriptionMatchedStatus_INITIALIZER : constant SubscriptionMatchedStatus := (others => <>);

    DataReaderCacheStatus_INITIALIZER (DataReaderCacheStatus)

    DataReaderCacheStatus_INITIALIZER : constant DataReaderCacheStatus := (others => <>);
    ---------------------------------------------------------- DataReaderProtocolStatus ----------------------------------------------------------

    DataReaderProtocolStatus_INITIALIZER (DataReaderProtocolStatus)

    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 => SEQUENCE_NUMBER_UNKNOWN,
                                                 Last_Available_Sample_Sequence_Number  => SEQUENCE_NUMBER_UNKNOWN,
                                                 Last_Committed_Sample_Sequence_Number  => SEQUENCE_NUMBER_UNKNOWN,
                                                 Uncommitted_Sample_Count               => 0,
                                                 Out_Of_Range_Rejected_Sample_Count     => 0,
                                                 Received_Fragment_Count                => 0,
                                                 Dropped_Fragment_Count                 => 0,
                                                 Reassembled_Sample_Count               => 0,
                                                 Sent_Nack_Fragment_Count               => 0,
                                                 Sent_Nack_Fragment_Bytes               => 0);

    READ_SAMPLE_STATE (SampleStateKind)

    READ_SAMPLE_STATE : constant SampleStateKind     := 1;

    Summary: Sample has been read.

    NOT_READ_SAMPLE_STATE (SampleStateKind)

    NOT_READ_SAMPLE_STATE : constant SampleStateKind := 2;

    Summary: Sample has not been read.

    ANY_SAMPLE_STATE (SampleStateMask)

    ANY_SAMPLE_STATE  : constant SampleStateMask := 16#FFFF#;

    NEW_VIEW_STATE (ViewStateKind)

    NEW_VIEW_STATE  : constant ViewStateKind     := 1;

    Summary: New instance. This latest generation of the instance has not previously been accessed.

    NOT_NEW_VIEW_STATE (ViewStateKind)

    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 (ViewStateMask)

    ANY_VIEW_STATE  : constant ViewStateMask := 16#FFFF#;

    Summary: Any view state DDS.NEW_VIEW_STATE | DDS.NOT_NEW_VIEW_STATE

    ALIVE_INSTANCE_STATE (InstanceStateKind)

    ALIVE_INSTANCE_STATE : constant InstanceStateKind                := 1;

    Summary: Instance is currently in existence.

    NOT_ALIVE_DISPOSED_INSTANCE_STATE (InstanceStateKind)

    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 (InstanceStateKind)

    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 (InstanceStateMask)

    NOT_ALIVE_INSTANCE_STATE : constant InstanceStateMask := 6;

    ANY_INSTANCE_STATE (InstanceStateMask)

    ANY_INSTANCE_STATE  : constant InstanceStateMask := 16#FFFF#;

    SQLFILTER_NAME (String)

    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 (String)

    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.

    Category_PLATFORM (LogCategory)

    Category_PLATFORM : constant LogCategory;

    Summary: Log messages pertaining to the underlying platform (hardware and OS) on which RTI Connext is running are in this category.

    Category_COMMUNICATION (LogCategory)

    Category_COMMUNICATION : constant LogCategory;

    Summary: Log messages pertaining to data serialization and deserialization and network traffic are in this category.

    Category_DATABASE (LogCategory)

    Category_DATABASE : constant LogCategory;

    Summary: Log messages pertaining to the internal database in which RTI Connext objects are stored are in this category.

    Category_ENTITIES (LogCategory)

    Category_ENTITIES : constant LogCategory;

    Summary: Log messages pertaining to local and remote entities, and to a subset of the discovery process, are in this category. (To see all discovery-related messages, use the DISCOVERY category.)

    Category_API (LogCategory)

    Category_API : constant LogCategory;

    Summary: Log messages pertaining to the API layer of RTI Connext (such as procedure argument validation) are in this category.

    VERBOSITY_SILENT (LogVerbosity)

    VERBOSITY_SILENT : constant LogVerbosity;

    Summary: No further output will be logged.

    VERBOSITY_ERROR (LogVerbosity)

    VERBOSITY_ERROR : constant LogVerbosity;

    Summary: Only error and fatal error messages will be logged.

    An error indicates something wrong in the functioning of dds. The most common cause of errors is incorrect configuration.

    VERBOSITY_WARNING (LogVerbosity)

    VERBOSITY_WARNING : constant LogVerbosity;

    Summary: Both error and warning messages will be logged.

    A warning indicates that RTI Connext is taking an action that may or may not be what you intended. Some configuration information is also logged at this verbosity to aid in debugging.

    VERBOSITY_STATUS_LOCAL (LogVerbosity)

    VERBOSITY_STATUS_LOCAL : constant LogVerbosity;

    Summary: Errors, warnings, and verbose information about the lifecycles of local RTI Connext objects will be logged.

    VERBOSITY_STATUS_REMOTE (LogVerbosity)

    VERBOSITY_STATUS_REMOTE : constant LogVerbosity;

    Summary: Errors, warnings, and verbose information about the lifecycles of remote RTI Connext objects will be logged.

    VERBOSITY_ALL (LogVerbosity)

    VERBOSITY_ALL : constant LogVerbosity;

    PRINT_NONE (LogPrintFormat)

    PRINT_NONE : constant LogPrintFormat;

    PRINT_BIT_NUMBER (LogPrintFormat)

    PRINT_BIT_NUMBER : constant LogPrintFormat;

    PRINT_BIT_MESSAGE (LogPrintFormat)

    PRINT_BIT_MESSAGE : constant LogPrintFormat;

    PRINT_BIT_LOCATION_MODULE (LogPrintFormat)

    PRINT_BIT_LOCATION_MODULE : constant LogPrintFormat;

    PRINT_BIT_LOCATION_FILELINE (LogPrintFormat)

    PRINT_BIT_LOCATION_FILELINE : constant LogPrintFormat;

    PRINT_BIT_LOCATION_METHOD (LogPrintFormat)

    PRINT_BIT_LOCATION_METHOD : constant LogPrintFormat;

    PRINT_BIT_TIMESTAMP (LogPrintFormat)

    PRINT_BIT_TIMESTAMP : constant LogPrintFormat;

    PRINT_BIT_THREAD_ID (LogPrintFormat)

    PRINT_BIT_THREAD_ID : constant LogPrintFormat;

    PRINT_BIT_CONTEXT (LogPrintFormat)

    PRINT_BIT_CONTEXT : constant LogPrintFormat;

    PRINT_BIT_TWO_LINES (LogPrintFormat)

    PRINT_BIT_TWO_LINES : constant LogPrintFormat;

    PRINT_FORMAT_DEFAULT (LogPrintFormat)

    PRINT_FORMAT_DEFAULT : constant LogPrintFormat;

    Summary: (default) Print message, method name, log level, DDSActivityContextModule (what was happening when the event occurred), and logging category.

    PRINT_FORMAT_TIMESTAMPED (LogPrintFormat)

    PRINT_FORMAT_TIMESTAMPED : constant LogPrintFormat;

    Summary: Print message, method name, log level, DDSActivityContextModule, logging category, and timestamp.

    PRINT_FORMAT_VERBOSE (LogPrintFormat)

    PRINT_FORMAT_VERBOSE : constant LogPrintFormat;

    Summary: Print message with all available context information (includes thread identifier, message location).

    PRINT_FORMAT_VERBOSE_TIMESTAMPED (LogPrintFormat)

    PRINT_FORMAT_VERBOSE_TIMESTAMPED : constant LogPrintFormat;

    Summary: Print message with all available context information, and timestamp.

    PRINT_FORMAT_DEBUG (LogPrintFormat)

    PRINT_FORMAT_DEBUG : constant LogPrintFormat;

    Summary: Print a set of fields (including message number and backtrace information) that may be useful for internal debugging.

    PRINT_FORMAT_MINIMAL (LogPrintFormat)

    PRINT_FORMAT_MINIMAL : constant LogPrintFormat;

    Summary: Print only message number and message location.

    PRINT_FORMAT_MAXIMAL (LogPrintFormat)

    PRINT_FORMAT_MAXIMAL : constant LogPrintFormat;

    Summary: Print all available fields.

    DEFAULT_FLOW_CONTROLLER_NAME (String)

    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 = 60 seconds

    - 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 = 60 seconds

    - 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 (String)

    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 (String)

    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 (FlowControllerSchedulingPolicy)

    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 (FlowControllerSchedulingPolicy)

    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)

    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 (ObjectSubState)

    OBJECT_NEW       : constant ObjectSubState := 2#0000_0000_0000_0001#;

    OBJECT_MODIFIED (ObjectSubState)

    OBJECT_MODIFIED  : constant ObjectSubState := 2#0000_0000_0000_0010#;

    OBJECT_READ (ObjectSubState)

    OBJECT_READ      : constant ObjectSubState := 2#0000_0000_0000_0100#;

    OBJECT_DELETED (ObjectSubState)

    OBJECT_DELETED   : constant ObjectSubState := 2#0000_0000_0000_1000#;

    OBJECT_CREATED (ObjectSubState)

    OBJECT_CREATED   : constant ObjectSubState := 2#0000_0001_0000_0000#;

    OBJECT_CHANGED (ObjectSubState)

    OBJECT_CHANGED   : constant ObjectSubState := 2#0000_0010_0000_0000#;

    OBJECT_WRITTEN (ObjectSubState)

    OBJECT_WRITTEN   : constant ObjectSubState := 2#0000_0100_0000_0000#;

    OBJECT_DESTROYED (ObjectSubState)

    OBJECT_DESTROYED : constant ObjectSubState := 2#0000_1000_0000_0000#;

    INFINITE_TIME_OUT (TimeOutDuration)

    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 (RelatedObjectDepth)

    UNLIMITED_RELATED_OBJECTS : constant RelatedObjectDepth    := -1;

    Not_Implemented

    Not_Implemented : exception;

    Subprograms & Entries

    Image

    function Image 
    (Item: Octet) return Standard.String;

    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.

    Length

    function Length 
    (Item: String) return Natural;

    Append

    procedure Append 
    (To: in out DDS.String;
    Data: DDS.String);

    Append

    procedure Append 
    (To: in out DDS.String;
    Data: Standard.String);

    Prepend

    procedure Prepend 
    (To: in out DDS.String;
    Data: DDS.String);

    Prepend

    procedure Prepend 
    (To: in out DDS.String;
    Data: Standard.String);

    WValue

    function WValue 
    (Item: Wchars_Ptr) return Interfaces.C.char16_array;

    +

    function "+" 
    (Left: Wchars_Ptr;
    Right: Interfaces.C.size_t) return Wchars_Ptr;

    Peek

    function Peek 
    (From: Wchars_Ptr) return Standard.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 => Interfaces.C.Strings.New_String (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_String) return DDS.Wide_String;

    To_Standard_Wide_String

    function To_Standard_Wide_String 
    (Source: DDS.Wide_String) return Standard.Wide_String;

    Copy

    procedure Copy 
    (Dst: in out DDS.Wide_String;
    Src: in Standard.Wide_String);

    Copy

    procedure Copy 
    (Dst: in out Standard.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 with Obsolescent => "Time + Time Does not make sense, but duration + duration does !";

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

    +

    function "+" 
    (L: Time_T;
    R: Duration_T) return Time_T;

    +

    function "+" 
    (L: Duration_T;
    R: Time_T) return Time_T;

    -

    function "-" 
    (L: Time_T;
    R: Duration_T) return Time_T;

    +

    function "+" 
    (L: Duration_T;
    R: Duration_T) return Duration_T;

    -

    function "-" 
    (L: Duration_T;
    R: Duration_T) return Duration_T;

    <

    function "<" 
    (L: Duration_T;
    R: Duration_T) return Boolean;

    >

    function ">" 
    (L: Duration_T;
    R: Duration_T) return Boolean;

    -

    function "-" 
    (L: Time_T;
    R: Time_T) 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

    =

    function "=" 
    (Self: not null access InstanceHandle_T;
    Other: not null access InstanceHandle_T) return Boolean renames InstanceHandle_Equals;

    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

    Hash

    function Hash 
    (Handle: DDS.InstanceHandle_T) return Ada.Containers.Hash_Type;

    Create

    function Create 
    (From: DDS.Guid_T) return DDS.InstanceHandle_T;

    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.

    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.

    other: <<in>> GUID to compare.

    Returns: If the two GUIDs are equal or ull_value, the function returns 0. If self is greater than other, the function returns a positive number; otherwise, it returns a negative number. Note that non- ull_value is considered greater than ull_value.

    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. Cannot be ull_value.

    Guid_Print

    procedure Guid_Print 
    (Self: Guid_T_Access;
    Desc: String;
    Indent: Unsigned_Long);

    Guid_Zero

    procedure Guid_Zero 
    (Self: Guid_T_Access);

    Image

    function Image 
    (Item: Guid_T) return DDS.String;

    Image

    function Image 
    (Item: Guid_T) return Standard.String;

    Value

    function Value 
    (Item: Standard.String) return Guid_T with Pre => (Item'Length = GUID_T_Value_Array'Length * 2);

    -

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

    Initialize

    procedure Initialize 
    (Self: in out Tags_T);

    Finalize

    procedure Finalize 
    (Self: in out Tags_T);

    Copy

    procedure Copy 
    (Dst: in out Tags_T;
    Src: in Tags_T);

    Lookup_Tag

    function Lookup_Tag 
    (Policy: in DataTagQosPolicy;
    Name: in DDS.String) return Tags_T_Access;

    lookup_tag: Searches by tag name for a tag in the input policy

    Precondition: policy, name and value cannot be null.

    policy: <<in>> Input policy.

    name: <<in>> Tag name.

    Returns: The function returns the first tag with the given name. If such a tag does not exist, the function returns NULL.

    Assert_Tag

    procedure Assert_Tag 
    (Policy: in DataTagQosPolicy;
    Name: in DDS.String;
    Value: in DDS.String);

    assert_tag: Asserts the tag identified by name in the input policy.

    If the tag already exists, this function replaces its current value with the new one.

    If the tag identified by name does not exist, this function adds it to the tag set.

    This function increases the maximum number of elements of the policy sequence by 10 when this number is not enough to store the new tag.

    Precondition: policy, name and value cannot be null.

    policy: <<in>> Input policy.

    name: <<in>> Tag name.

    value: <<in>> Tag value.

    Raises: One of the DDSReturnTypesModules_std_retcodes, DDS.RETCODE_OUT_OF_RESOURCES

    Add_Tag

    procedure Add_Tag 
    (Policy: in DataTagQosPolicy;
    Name: in DDS.String;
    Value: in DDS.String);

    add_tag: Adds a new tag to the input policy.

    This function will allocate memory to store the (name, value) pair. The memory allocated is owned by dds.

    If the maximum number of elements of the policy sequence is not enough to store the new tag, this function will increase it by 10.

    If the tag already exists, the function will fail with DDS.RETCODE_PRECONDITION_NOT_MET.

    Precondition: policy, name and value cannot be null. Precondition: The tag is not in the policy.

    policy: <<in>> Input policy.

    name: <<in>> Tag name.

    value: <<in>> Tag value.

    Raises: One of the DDSReturnTypesModules_std_retcodes, DDS.RETCODE_PRECONDITION_NOT_MET, DDS.RETCODE_OUT_OF_RESOURCES

    Remove_Tag

    procedure Remove_Tag 
    (Policy: in DataTagQosPolicy;
    Name: in DDS.String);

    remove_tag: Removes a tag from the input policy.

    If the tag does not exist, the function fails with DDS.RETCODE_PRECONDITION_NOT_MET.

    Precondition: policy and name cannot be null.

    Precondition: The tag is in the policy.

    policy: <<in>> Input policy.

    name: <<in>> Tag name.

    Raises: One of the DDSReturnTypesModules_std_retcodes, DDS.RETCODE_PRECONDITION_NOT_MET

    Get_Number_Of_Tags

    function Get_Number_Of_Tags 
    (Policy: in DataTagQosPolicy) return DDS.Long;

    get_number_of_tags: Gets the number of data tags in the input policy.

    Precondition: policy cannot be null.

    policy: <<in>> Input policy.

    Returns: Number of data tags.

    +

    function "+" 
    (Left, Right: aliased AllocationSettings_T) return AllocationSettings_T;

    =

    function "=" 
    (Left, Right: DurabilityQosPolicy) return Standard.Boolean;

    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 DataRepresentationId_T);

    Finalize

    procedure Finalize   
    (Self: in out DataRepresentationId_T);

    Copy

    procedure Copy 
    (Dst: in out DataRepresentationId_T;
    Src: in DataRepresentationId_T);

    Contains

    function Contains 
    (Policy: in DataRepresentationQosPolicy;
    Id: in DataRepresentationId_T) return Standard.Boolean;

    Equals

    function Equals 
    (Left, Right: in DataRepresentationQosPolicy) return Standard.Boolean;

    =

    function "=" 
    (Left, Right: in DataRepresentationQosPolicy) return Standard.Boolean renames Equals;

    Get_Native_Encapsulation

    function Get_Native_Encapsulation 
    (Id: in DataRepresentationId_T) return EncapsulationId_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);

    Hash

    function Hash 
    (Item: DDS.BuiltinTopicKey_T) return Ada.Containers.Hash_Type;

    BuiltinTopicKey_Equals

    function BuiltinTopicKey_Equals 
    (A: in BuiltinTopicKey_T_Access;
    B: in BuiltinTopicKey_T_Access) return DDS.Boolean;

    DataWriterShmemRefTransferModeSettings_Equals

    function DataWriterShmemRefTransferModeSettings_Equals 
    (Self: in DataWriterShmemRefTransferModeSettings_Access;
    Other: in DataWriterShmemRefTransferModeSettings_Access) return DDS.Boolean;

    DataWriterTransferModeQosPolicy_Equals

    function DataWriterTransferModeQosPolicy_Equals 
    (Self: in DataWriterTransferModeQosPolicy_Access;
    Other: in DataWriterTransferModeQosPolicy_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;

    Add_Property

    procedure Add_Property 
    (Policy: in PropertyQosPolicy_Access;
    Name: in Standard.String;
    Value: in Standard.String;
    Propagate: in DDS.Boolean);

    Summary: Adds a new property to the input policy.

    This function will allocate memory to store the (name, value) pair. The memory allocated is owned by dds.

    If the maximum number of elements of the policy sequence is not enough to store the new property, this function will increase it.

    If the property already exists the function fails with DDS.RETCODE_PRECONDITION_NOT_MET.

    Precondition: policy, name and value cannot be null. Precondition: The property is not in the policy.

    policy: <<in>> Input policy.

    name: <<in>> Property name.

    value: <<in>> Property value.

    propagate: <<in>> Indicates if the property will be propagated on discovery.

    Raises: One of the DDSReturnTypesModules_std_retcodes, DDS.RETCODE_PRECONDITION_NOT_MET, DDS.RETCODE_OUT_OF_RESOURCES

    Remove_Property

    procedure Remove_Property 
    (Policy: in PropertyQosPolicy_Access;
    Name: in Standard.String);

    Summary: Removes a property from the input policy.

    If the property does not exist, the function fails with DDS.RETCODE_PRECONDITION_NOT_MET.

    Precondition: policy and name cannot be null.

    Precondition: The property is in the policy.

    policy: <<in>> Input policy.

    name: <<in>> Property name.

    Raises: One of the DDSReturnTypesModules_std_retcodes, DDS.RETCODE_PRECONDITION_NOT_MET

    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;

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

    Initialize

    procedure Initialize 
    (Self: in out WriteParams_T);

    Finalize

    procedure Finalize   
    (Self: in out WriteParams_T);

    Copy

    procedure Copy       
    (Dst: in out WriteParams_T;
    Src: in WriteParams_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);

    Hash

    function Hash 
    (Item: DDS.ParticipantBuiltinTopicData) return Ada.Containers.Hash_Type;

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

    Hash

    function Hash 
    (Item: DDS.PublicationBuiltinTopicData) return Ada.Containers.Hash_Type;

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

    Hash

    function Hash 
    (Item: DDS.SubscriptionBuiltinTopicData) return Ada.Containers.Hash_Type;

    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

    @warning Only the field DDS.DestinationOrderQosPolicy.kind is propagated during discovery. The other fields always contain their default values.

    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

    Representation: Data representation policy of the corresponding DataReader

    Data_Tags: Tags 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_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);

    Get_Sample_Identity

    procedure Get_Sample_Identity 
    (From: SampleInfo;
    Id: out SampleIdentity_T);

    Get_Sample_Identity

    function Get_Sample_Identity 
    (From: SampleInfo) return SampleIdentity_T;

    Get_Related_Sample_Identity

    procedure Get_Related_Sample_Identity 
    (From: SampleInfo;
    Id: out SampleIdentity_T);

    Get_Related_Sample_Identity

    function Get_Related_Sample_Identity 
    (From: SampleInfo) return SampleIdentity_T;

    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

    +

    function "+" 
    (Left, Right: LogVerbosity) return LogVerbosity;

    Image

    function Image 
    (Item: LogVerbosity) return Standard.String;

    Contains

    function Contains 
    (Self: LogVerbosity;
    Verbosity: LogVerbosity) return Boolean;

    +

    function "+" 
    (Left, Right: LogPrintFormat) return LogPrintFormat;

    Initialize

    procedure Initialize 
    (Self: in out MonitoringMetricSelection);

    Finalize

    procedure Finalize 
    (Self: in out MonitoringMetricSelection);

    Copy

    procedure Copy 
    (Dst: in out MonitoringMetricSelection;
    Src: in MonitoringMetricSelection);

    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.

    @condparam{JAVA_LANGUAGE_ONLY, theLength, size, <<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).

    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.

    @condparam{JAVA_LANGUAGE_ONLY, theLength, size, <<in>> Size of the allocated octets array.}

    Raises: IllegalArgumentException if size is negative

    KeyedOctets_Delete

    procedure KeyedOctets_Delete 
    (Self: KeyedOctets_Ptr);

    Summary: Destructor.

    Convert

    function Convert 
    (Code: RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReturnCode_t) return DDS.ReturnCode_T;

    Ret_Code_To_Exception

    procedure Ret_Code_To_Exception 
    (Code: RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_ReturnCode_t;
    Message: Standard.String := "");

    Ret_Code_To_Exception

    procedure Ret_Code_To_Exception 
    (Code: RTIDDS.Low_Level.ndds_dds_c_dds_c_common_h.DDS_Boolean;
    Message: Standard.String := "");