package Short_Seq is new DDS_Support.Sequences_Generic (Short, Short_Ptr, DDS.Natural, 1, Short_Array);
package Long_Seq is new DDS_Support.Sequences_Generic (Long, Long_Ptr, DDS.Natural, 1, Long_Array);
package Long_Long_Seq is new DDS_Support.Sequences_Generic (Long_Long, Long_Long_Ptr, DDS.Natural, 1, Long_Long_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.LongLong
See also: FooSeq
package Unsigned_Short_Seq is new DDS_Support.Sequences_Generic (Unsigned_Short, Unsigned_Short_Ptr, DDS.Natural, 1, Unsigned_Short_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedShort
See also: FooSeq
package Unsigned_Long_Seq is new DDS_Support.Sequences_Generic (Unsigned_Long, Unsigned_Long_Ptr, DDS.Natural, 1, Unsigned_Long_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedLong
See also: FooSeq
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);
Instantiates:
<<generic>> FooSeq
See also: DDS.UnsignedLongLong
See also: FooSeq
package Enum_Seq is new DDS_Support.Sequences_Generic (Enum, Enum_Ptr, DDS.Natural, 1, Enum_Array);
package Float_Seq is new DDS_Support.Sequences_Generic (Float, Float_Ptr, DDS.Natural, 1, Float_Array);
package Double_Seq is new DDS_Support.Sequences_Generic (Double, Double_Ptr, DDS.Natural, 1, Double_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.Double
See also: FooSeq
package Long_Double_Seq is new DDS_Support.Sequences_Generic (Long_Double, Long_Double_Ptr, DDS.Natural, 1, Long_Double_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.LongDouble
See also: FooSeq
package Char_Seq is new DDS_Support.Sequences_Generic (Char, Char_Ptr, DDS.Natural, 1, Char_Array);
package Wchar_Seq is new DDS_Support.Sequences_Generic (Wchar, Wchar_Ptr, DDS.Natural, 1, Wchar_Array);
package Octet_Seq is new DDS_Support.Sequences_Generic (Octet, Octet_Ptr, DDS.Natural, 1, Octet_Array);
package Octets_Seq is new DDS_Support.Sequences_Generic (Octets, Octets_Ptr, DDS.Natural, 1, Octets_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS_Octets
package Boolean_Seq is new DDS_Support.Sequences_Generic (Boolean, Boolean_Ptr, DDS.Natural, 1, Boolean_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.Boolean
See also: FooSeq
package String_Seq is new DDS_Support.Sequences_Generic (DDS.String, String_Ptr, DDS.Natural, 1, String_Array);
StringSeq is a sequence that contains strings.
Instantiates:
<<generic>> FooSeq
See also: FooSeq
package KeyedString_Seq is new DDS_Support.Sequences_Generic (DDS.KeyedString, KeyedString_Ptr, DDS.Natural, 1, KeyedString_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS_KeyedString
package KeyedOctets_Seq is new DDS_Support.Sequences_Generic (DDS.KeyedOctets, KeyedOctets_Ptr, DDS.Natural, 1, KeyedOctets_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS_KeyedOctets
package Wide_String_Seq is new DDS_Support.Sequences_Generic (DDS.Wide_String, Wide_String_Ptr, DDS.Natural, 1, Wide_String_Array);
package InstanceHandle_Seq is new DDS_Support.Sequences_Generic (InstanceHandle_T, InstanceHandle_T_Access, DDS.Natural, 1, InstanceHandle_T_Array);
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
package QosPolicyCount_Seq is new DDS_Support.Sequences_Generic (QosPolicyCount, QosPolicyCount_Access, DDS.Natural, 1, QosPolicyCount_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.QosPolicyCount
package Tags_Seq is new DDS_Support.Sequences_Generic (Tags_T, Tags_T_Access, DDS.Natural, 1, Tags_T_Array);
See also: DDS.Tag
package TransportUnicastSettings_Seq is new DDS_Support.Sequences_Generic (TransportUnicastSettings_T, TransportUnicastSettings_T_Access, DDS.Natural, 1, TransportUnicastSettings_T_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.TransportUnicastSettings_t
package TransportMulticastSettings_Seq is new DDS_Support.Sequences_Generic (TransportMulticastSettings_T, TransportMulticastSettings_T_Access, DDS.Natural, 1, TransportMulticastSettings_T_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.TransportMulticastSettings_t
package TransportMulticastMapping_Seq is new DDS_Support.Sequences_Generic (TransportMulticastMapping_T, TransportMulticastMapping_T_Access, DDS.Natural, 1, TransportMulticastMapping_T_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.TransportMulticastMapping_t
package EncapsulationId_Seq is new DDS_Support.Sequences_Generic (EncapsulationId_T, EncapsulationId_T_Access, DDS.Natural, 1, EncapsulationId_T_Array);
package TransportEncapsulationSettings_Seq is new DDS_Support.Sequences_Generic (TransportEncapsulationSettings_T, TransportEncapsulationSettings_T_Access, DDS.Natural, 1, TransportEncapsulationSettings_T_Array);
package DataRepresentationId_Seq is new DDS_Support.Sequences_Generic (DataRepresentationId_T, DataRepresentationId_T_Access, DDS.Natural, 1, DataRepresentationId_T_Array);
See also: DDS.DataRepresentationId_t
package Discovery_ParticipantInformationSeq is new DDS_Support.Sequences_Generic (Discovery_ParticipantInformation, Discovery_ParticipantInformation_Access, DDS.Natural, 1, Discovery_ParticipantInformation_Array);
package Discovery_EndpointInformationSeq is new DDS_Support.Sequences_Generic (Discovery_EndpointInformation, Discovery_EndpointInformation_Access, DDS.Natural, 1, Discovery_EndpointInformation_Array);
package Locator_Seq is new DDS_Support.Sequences_Generic (Locator_T, Locator_T_Access, DDS.Natural, 1, Locator_T_Array);
See also: DDS.Locator_t
package LocatorFilter_Seq is new DDS_Support.Sequences_Generic (LocatorFilter_T, LocatorFilter_T_Access, DDS.Natural, 1, LocatorFilter_T_Array);
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
package ChannelSettings_Seq is new DDS_Support.Sequences_Generic (ChannelSettings_T, ChannelSettings_T_Access, DDS.Natural, 1, ChannelSettings_T_Array);
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
package Property_T_Seq is new DDS_Support.Sequences_Generic (Property_T, Property_T_Access, DDS.Natural, 1, Property_T_Array);
See also: DDS.Property_t
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);
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
package Cookie_T_Seq is new DDS_Support.Sequences_Generic (Cookie_T, Cookie_T_Access, DDS.Natural, 1, Cookie_T_Array);
See also: FooSeq
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);
package ParticipantBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic (Element => DDS.ParticipantBuiltinTopicData, Element_Access => DDS.ParticipantBuiltinTopicData_Access, Index_Type => Natural, First_Element => 1, Element_Array => DDS.ParticipantBuiltinTopicData_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.ParticipantBuiltinTopicData
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);
Instantiates:
<<generic>> FooSeq
See also: DDS.TopicBuiltinTopicData
package PublicationBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic (Element => DDS.PublicationBuiltinTopicData, Element_Access => DDS.PublicationBuiltinTopicData_Access, Index_Type => Natural, First_Element => 1, Element_Array => DDS.PublicationBuiltinTopicData_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.PublicationBuiltinTopicData
package SubscriptionBuiltinTopicData_Seq is new DDS_Support.Sequences_Generic (Element => DDS.SubscriptionBuiltinTopicData, Element_Access => DDS.SubscriptionBuiltinTopicData_Access, Index_Type => Natural, First_Element => 1, Element_Array => DDS.SubscriptionBuiltinTopicData_Array);
Instantiates:
<<generic>> FooSeq
See also: DDS.SubscriptionBuiltinTopicData
package SampleInfo_Seq is new DDS_Support.Sequences_Generic (SampleInfo, SampleInfo_Access, DDS.Natural, 1, SampleInfo_Array);
See also: FooSeq
package MonitoringMetricSelection_Seq is new DDS_Support.Sequences_Generic (MonitoringMetricSelection, MonitoringMetricSelection_Access, DDS.Natural, 1, MonitoringMetricSelection_Array);
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;
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.
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;
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.
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;
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.
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;
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.
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;
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.
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;
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.
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;
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.
subtype Integer is Long;
type Enum is new Interfaces.Unsigned_32;
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.
type Float is new Interfaces.IEEE_Float_32;
A 32-bit floating-point value.
type Double is new Interfaces.IEEE_Float_64;
A 64-bit floating-point value.
type Long_Double is new Interfaces.IEEE_Extended_Float;
A 128-bit floating-point value.
subtype Char is Standard.Character;
An 8-bit quantity that encodes a single byte charater from any byte-oriented code set.
subtype Wchar is Standard.Wide_Character;
A 16-bit quantity that contains a wide character encoded in UTF-16.
subtype Octet is Interfaces.Unsigned_8;
An 8-bit quantity that is guaranteed not to undergo any conversion when transmitted by the middleware.
type Octets is record Length : Integer; Value : System.Address; end record with Convention => C;
subtype Boolean is Standard.Boolean;
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;
Has a range of ISO Latin-1 (except ASCII NULL) and a variable length.
type KeyedString is record Key : DDS.String; Value : DDS.String; end record with Convention => C;
type KeyedOctets is record Key : DDS.String; Value : Octets; end record with Convention => C;
type Wide_String is limited record Data : Wchars_Ptr; end record with Convention => C;
type Short_Ptr is access all Short;
type Long_Ptr is access all Long;
type Long_Long_Ptr is access all Long_Long;
type Unsigned_Short_Ptr is access all Unsigned_Short;
type Unsigned_Long_Ptr is access all Unsigned_Long;
type Unsigned_Long_Long_Ptr is access all Unsigned_Long_Long;
type Enum_Ptr is access all Enum;
type Float_Ptr is access all Float;
type Double_Ptr is access all Double;
type Long_Double_Ptr is access all Long_Double;
type Char_Ptr is access all Char;
type Wchar_Ptr is access all Wchar;
type Octet_Ptr is access all Octet;
type Octets_Ptr is access all Octets;
type Boolean_Ptr is access all Boolean;
type String_Ptr is access all String;
type KeyedString_Ptr is access all KeyedString;
type KeyedOctets_Ptr is access all KeyedOctets;
type Wide_String_Ptr is access all Wide_String;
type DomainId_T is new Long range 0 .. DOMAIN_ID_MAX;
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)
type Unsigned_Short_Array is array (Natural range <>) of aliased Unsigned_Short;
type Unsigned_Long_Array is array (Natural range <>) of aliased Unsigned_Long;
type Unsigned_Long_Long_Array is array (Natural range <>) of aliased Unsigned_Long_Long;
type Long_Double_Array is array (Natural range <>) of aliased Long_Double;
type String_Array is array (Natural range <>) of aliased DDS.String;
type KeyedString_Array is array (Natural range <>) of aliased DDS.KeyedString;
type KeyedOctets_Array is array (Natural range <>) of aliased DDS.KeyedOctets;
type Wide_String_Array is array (Natural range <>) of aliased DDS.Wide_String;
type Time_T is record Sec : Long_Long := 0; Nanosec : Unsigned_Long := 0; end record with Convention => C;
A DDS.Time_t represents a moment in time.
Sec: seconds
Nanosec: nanoseconds
[range] [0,1000000000)
type Duration_T is record -- Default DURATION_ZERO Sec : Long := 0; Nanosec : Unsigned_Long := 0; end record with Convention => C;
Represents a time interval.
Sec: seconds
Nanosec: nanoseconds
[range] [0,1000000000)
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;
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.
type InstanceHandle_T is new RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_InstanceHandle_t;
type InstanceHandle_T_Access is access all InstanceHandle_T;
type InstanceHandle_T_Array is array (Natural range <>) of aliased InstanceHandle_T;
subtype GUID_T_Value_Array is Octet_Array (0 .. 15);
type Guid_T is record Value : aliased GUID_T_Value_Array := (others => 0); end record with Convention => C;
type Guid_T_Access is access all Guid_T;
type SequenceNumber_T is record High : aliased DDS.Long := 0; Low : aliased DDS.Unsigned_Long := 0; end record with Convention => C;
Represents a 64-bit sequence number.
High: The most significant part of the sequence number
Low: The least significant part of the sequence number
type SequenceNumber_T_Access is access all SequenceNumber_T;
type OriginalWriterInfo_T is record Writer_Guid : Guid_T; Sequence_Number : SequenceNumber_T; end record with Convention => C;
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;
type StatusKind is new Unsigned_Long;
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
subtype StatusMask is 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.
type StatusKind_Access is access constant StatusKind;
subtype ThreadSettingsKindMask is ThreadSettings;
See also: DDS.ThreadSettings_t
type ThreadSettingsCpuRotationKind_T is new Unsigned_Long;
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.
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;
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.
type ThreadSettings_T_Access is access all ThreadSettings_T;
type QosPolicyCount is record Policy_Id : aliased QosPolicyId_T := INVALID_QOS_POLICY_ID; Count : aliased Long := 0; end record with Convention => C;
type QosPolicyCount_Access is access all QosPolicyCount;
type QosPolicyCount_Array is array (Natural range <>) of aliased QosPolicyCount;
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);
type UserDataQosPolicy is limited record Value : aliased Octet_Seq.Sequence; end record with Convention => C;
Entity:
DDS.DomainParticipant, DDS.DataReader, DDS.DataWriter
Properties:
"Rx0" = NO;
"Changeable" = "YES"
See also: DDS.DomainParticipant.get_builtin_subscriber
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]
type TopicDataQosPolicy is limited record Value : aliased Octet_Seq.Sequence; end record with Convention => C;
type Tags_T is limited record Name : aliased DDS.String; Value : aliased DDS.String; end record with Convention => C;
type Tags_T_Access is access all Tags_T with Convention => C;
type DataTagQosPolicy is limited record Value : aliased Tags_Seq.Sequence; end record with Convention => C;
Entity:
DDS.DataReader DDS.DataWriter
Properties:
"Rx0" = N/A;
"Changeable" = "NO"
There are helper functions to facilitate working with data tags. See the DDSDataTagQosModule page.
Value: Sequence of data tags.
[default] An empty list.
type GroupDataQosPolicy is limited record Value : aliased Octet_Seq.Sequence; end record with Convention => C;
Entity:
DDS.Publisher, DDS.Subscriber
Properties:
"Rx0" = NO
"Changeable" = "YES"
See also: DDS.DomainParticipant.get_builtin_subscriber
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]
type TopicProtocolQosPolicy is limited record Vendor_Specific_Entity : Boolean := False; end record with Convention => C;
type DomainParticipantProtocolQosPolicy is limited record Vendor_Specific_Entity : Boolean := False; end record with Convention => C;
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;
type AllocationSettings_T_Access is access all AllocationSettings_T;
type DurabilityQosPolicyKind is new Unsigned_Long;
type PersistentJournalKind is new Unsigned_Long;
The rollback journal is used in SQLite to store the state of the persistent storage before a transaction is committed.
type PersistentSynchronizationKind is new Unsigned_Long;
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;
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;
type DurabilityQosPolicy_Access is access all DurabilityQosPolicy;
type PresentationQosPolicyAccessScopeKind is new Unsigned_Long;
Access scope determines the largest scope spanning the entities for which the order and coherency of changes can be preserved.
QoS:
DDS.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;
type DeadlineQosPolicy is record Period : aliased Duration_T := DURATION_INFINITE; end record with Convention => C;
type LatencyBudgetQosPolicy is record Duration : aliased Duration_T := DURATION_ZERO; end record with Convention => C;
type OwnershipQosPolicyKind is new Unsigned_Long;
type OwnershipQosPolicy is record Kind : aliased OwnershipQosPolicyKind := SHARED_OWNERSHIP_QOS; end record with Convention => C;
type OwnershipStrengthQosPolicy is record Value : aliased Long := 0; end record with Convention => C;
type LivelinessQosPolicyKind is new Unsigned_Long;
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;
type TimeBasedFilterQosPolicy is record Minimum_Separation : aliased Duration_T := DURATION_ZERO; end record with Convention => C;
type PartitionQosPolicy is record Name : aliased String_Seq.Sequence; end record with Convention => C;
type ReliabilityQosPolicyKind is new Unsigned_Long;
type ReliabilityQosPolicyAcknowledgmentModeKind is new Unsigned_Long;
type InstanceStateRecoveryKind is (NO_INSTANCE_STATE_RECOVERY, RECOVER_INSTANCE_STATE_RECOVERY);
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.
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;
type DestinationOrderQosPolicyKind is new Unsigned_Long;
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;
type HistoryQosPolicyKind is new Unsigned_Long;
type HistoryQosPolicy is record Kind : aliased HistoryQosPolicyKind := KEEP_LAST_HISTORY_QOS; Depth : aliased Long := 1; end record with Convention => C;
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;
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;
type TransportPriorityQosPolicy is record Value : aliased Long := 0; end record with Convention => C;
type LifespanQosPolicy is record Duration : aliased Duration_T := DURATION_INFINITE; end record with Convention => C;
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;
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;
type EntityFactoryQosPolicy is record Autoenable_Created_Entities : aliased DDS.Boolean := True; end record with Convention => C;
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;
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;
type UserObjectSettings_T is record Size : aliased Long := 0; Alignment : aliased Long := 0; end record with Convention => C;
type TransportUnicastSettings_T is record Transports : aliased String_Seq.Sequence; Receive_Port : aliased Long := 0; end record with Convention => C;
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.
type TransportUnicastSettings_T_Access is access all TransportUnicastSettings_T;
type TransportUnicastSettings_T_Array is array (Natural range <>) of aliased TransportUnicastSettings_T;
type TransportMulticastSettings_T is record Transports : DDS.String_Seq.Sequence; Receive_Address : DDS.String; Receive_Port : Long := 0; end record with Convention => C;
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]
type TransportMulticastSettings_T_Access is access all TransportMulticastSettings_T;
type TransportMulticastSettings_T_Array is array (Natural range <>) of aliased TransportMulticastSettings_T;
type TransportMulticastMappingFunction_T is record Dll : DDS.String; Function_Name : DDS.String; end record with Convention => C;
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.
type TransportMulticastMapping_T is record Addresses : DDS.String; Topic_Expression : DDS.String; Mapping_Function : TransportMulticastMappingFunction_T; end record with Convention => C;
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.
type TransportMulticastMapping_T_Access is access all TransportMulticastMapping_T;
type TransportMulticastMapping_T_Array is array (Natural range <>) of aliased TransportMulticastMapping_T;
type EncapsulationId_T_Access is access all EncapsulationId_T;
type EncapsulationId_T_Array is array (Natural range <>) of aliased EncapsulationId_T;
type TransportEncapsulationSettings_T is record Transports : aliased DDS.String_Seq.Sequence; Encapsulations : aliased EncapsulationId_Seq.Sequence; end record with Convention => C;
type TransportEncapsulationSettings_T_Access is access all TransportEncapsulationSettings_T;
type TransportEncapsulationSettings_T_Array is array (Natural range <>) of aliased TransportEncapsulationSettings_T;
type DataRepresentationId_T is new RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_DataRepresentationId_t with Convention => C;
type DataRepresentationId_T_Access is access all DataRepresentationId_T;
type DataRepresentationId_T_Array is array (Natural range <>) of aliased DataRepresentationId_T;
type DataRepresentationQosPolicy is limited record Value : aliased DataRepresentationId_Seq.Sequence; Compression_Settings : aliased CompressionSettings_T := COMPRESSION_SETTINGS_T_DEFAULT; end record with Convention => C;
type TransportSelectionQosPolicy is record Enabled_Transports : aliased DDS.String_Seq.Sequence := DDS.String_Seq.DEFAULT_SEQUENCE; end record with Convention => C;
type TransportUnicastQosPolicy is record Value : TransportUnicastSettings_Seq.Sequence; end record with Convention => C;
type TransportMulticastQosPolicyKind is new Unsigned_Long;
See also: DDS.TransportMulticastQosPolicy
type TransportMulticastQosPolicy is record Value : TransportMulticastSettings_Seq.Sequence := TransportMulticastSettings_Seq.DEFAULT_SEQUENCE; Kind : TransportMulticastQosPolicyKind := AUTOMATIC_TRANSPORT_MULTICAST_QOS; end record with Convention => C;
type TransportMulticastMappingQosPolicy is record Value : TransportMulticastMapping_Seq.Sequence; end record with Convention => C;
type TransportEncapsulationQosPolicy is record Value : aliased TransportEncapsulationSettings_Seq.Sequence; end record with Convention => C;
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;
Entity:
DDS.DomainParticipant
Properties:
"Rx0" = N/A
"Changeable" = "NO"
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
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;
type Discovery_ParticipantInformation_Access is access all Discovery_ParticipantInformation;
type Discovery_ParticipantInformation_Array is array (Natural range <>) of aliased Discovery_ParticipantInformation;
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;
type Discovery_EndpointInformation_Access is access all Discovery_EndpointInformation;
type Discovery_EndpointInformation_Array is array (Natural range <>) of aliased Discovery_EndpointInformation;
type TransportBuiltinKind is new Unsigned_Long;
See also: DDS.TransportBuiltinKindMask
subtype TransportBuiltinKindMask is TransportBuiltinKind;
type TransportBuiltinQosPolicy is record Mask : TransportBuiltinKindMask; end record with Convention => C;
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;
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.
type RtpsReservedPortKind is new Unsigned_Long;
See also: DDS.WireProtocolQosPolicy.rtps_reserved_port_mask
subtype RtpsReservedPortKindMask is RtpsReservedPortKind;
type WireProtocolQosPolicyAutoKind is new Unsigned_Long;
See also: DDS.WireProtocolQosPolicy.rtps_auto_id_kind
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;
type Locator_Address_Array_T is array (0 .. LOCATOR_ADDRESS_LENGTH_MAX - 1) of Octet;
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;
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.
type Locator_T_Access is access all Locator_T;
type ProtocolVersion_T is record Major : aliased Octet := 0; Minor : aliased Octet := 0; end record with Convention => C;
Major: Major protocol version number
Minor: Minor protocol version number
type VendorId_Array_T is array (0 .. VENDOR_ID_LENGTH_MAX - 1) of Octet;
type VendorId_T is record VendorId : aliased VendorId_Array_T := (others => 0); end record with Convention => C;
VendorId: The vendor Id.
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;
Major: Major product version.
Minor: Minor product version.
Release: Release letter for product version.
Revision: Revision number of product.
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;
[default]
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
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;
type DataWriterResourceLimitsInstanceReplacementKind is new Unsigned_Long;
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:
QoS:
DDS.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;
type ServiceQosPolicyKind is new Unsigned_Long;
type ServiceQosPolicy is record Kind : ServiceQosPolicyKind := NO_SERVICE_QOS; end record with Convention => C;
type PublisherProtocolQosPolicy is record Vendor_Specific_Entity : DDS.Boolean := False; end record with Convention => C;
type SubscriberProtocolQosPolicy is record Vendor_Specific_Entity : DDS.Boolean := False; end record with Convention => C;
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;
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;
type DomainParticipantResourceLimitsIgnoredEntityReplacementKind is new Unsigned_Long;
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;
type EventQosPolicy is record Thread : aliased ThreadSettings_T; Initial_Count : aliased Long := 256; Max_Count : aliased Long := -1; end record with Convention => C;
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;
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;
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;
type BuiltinTopicKey_Array_T is array (0 .. BUILTIN_TOPIC_KEY_TYPE_NATIVE_LENGTH - 1) of Builtin_Topic_Key_Type_Native;
type BuiltinTopicKey_T is record Value : BuiltinTopicKey_Array_T := (others => 0); end record with Convention => C;
type BuiltinTopicKey_T_Access is access all BuiltinTopicKey_T;
type PublishModeQosPolicyKind is new Unsigned_Long;
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;
type DiscoveryConfigBuiltinPluginKind is new DDS.Unsigned_Long;
See also: DDS.DiscoveryConfigBuiltinPluginKindMask
subtype DiscoveryConfigBuiltinPluginKindMask is DiscoveryConfigBuiltinPluginKind;
The bit-mask is an efficient and compact representation of a fixed-length list of DDS.DiscoveryConfigBuiltinPluginKind values.
type RemoteParticipantPurgeKind is new Unsigned_Long;
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
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;
type TypeSupportQosPolicy is record Plugin_Data : aliased DDS_Support.Void_Ptr; Cdr_Padding_Kind : aliased CdrPaddingKind; end record with Convention => C;
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;
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;
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;
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;
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;
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;
type ExclusiveAreaQosPolicy is record Use_Shared_Exclusive_Area : aliased DDS.Boolean; Level : aliased DDS.Long; end record with Convention => C;
type DataWriterShmemRefTransferModeSettings is record Enable_Data_Consistency_Check : aliased DDS.Boolean; end record with Convention => C;
type DataWriterShmemRefTransferModeSettings_Access is access all DataWriterShmemRefTransferModeSettings;
type DataWriterTransferModeQosPolicy is record Shmem_Ref_Settings : aliased DataWriterShmemRefTransferModeSettings; end record with Convention => C;
type DataWriterTransferModeQosPolicy_Access is access all DataWriterTransferModeQosPolicy;
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;
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;
type TypeConsistencyKind is new Unsigned_Long;
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;
type LocatorFilter_T is record Locators : aliased Locator_Seq.Sequence; Filter_Expression : DDS.String; end record with Convention => C;
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)
type LocatorFilter_T_Access is access all LocatorFilter_T;
type LocatorFilter_T_Array is array (Natural range <>) of aliased LocatorFilter_T;
type LocatorFilterQosPolicy is record Locator_Filters : aliased DDS.LocatorFilter_Seq.Sequence; Filter_Name : aliased DDS.String; end record with Convention => C;
type ChannelSettings_T is record Multicast_Settings : aliased TransportMulticastSettings_Seq.Sequence; Filter_Expression : DDS.String; Priority : DDS.Long; end record with Convention => C;
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
type ChannelSettings_T_Access is access all ChannelSettings_T;
type ChannelSettings_T_Array is array (Natural range <>) of aliased ChannelSettings_T;
type MultiChannelQosPolicy is record Channels : aliased DDS.ChannelSettings_Seq.Sequence; Filter_Name : aliased DDS.String; end record with Convention => C;
type Property_T is record Name : aliased DDS.String; Value : aliased DDS.String; Propagate : aliased DDS.Boolean := False; end record with Convention => C;
Name: Property name.
Value: Property value.
Propagate: Indicates if the property must be propagated on discovery.
type Property_T_Access is access all Property_T;
type Property_T_Array is array (Natural range <>) of aliased Property_T;
type Property_T_Seq_Access is access all Property_T_Seq.Sequence;
type PropertyQosPolicy is record Value : aliased Property_T_Seq.Sequence; end record with Convention => C;
type PropertyQosPolicy_Access is access all PropertyQosPolicy;
type WaitSetProperty_T is record Max_Event_Count : aliased Long := 0; Max_Event_Delay : aliased Duration_T; end record with Convention => C;
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
type EndpointGroup_T is record Role_Name : aliased DDS.String; Quorum_Count : aliased Integer := 0; end record with Convention => C;
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.
type EndpointGroup_T_Access is access all EndpointGroup_T;
type EndpointGroup_T_Array is array (Natural range <>) of aliased EndpointGroup_T;
type EndpointGroup_T_Seq_Access is access all EndpointGroup_T_Seq.Sequence;
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;
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;
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.
type EntityNameQosPolicy is record Name : aliased DDS.String; Role_Name : aliased DDS.String; end record with Convention => C;
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;
type SampleIdentity_T is record Writer_Guid : aliased Guid_T; Sequence_Number : aliased DDS.SequenceNumber_T; end record with Convention => C;
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.
type Cookie_T is record Value : aliased Octet_Seq.Sequence; end record with Convention => C;
type Cookie_T_Access is access all Cookie_T;
type AckResponseData_T is record Value : aliased Octet_Seq.Sequence; end record with Convention => C;
type SampleFlagBits is new Unsigned_Long;
subtype SampleFlag is SampleFlagBits;
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;
type WriteParams_T_Access is access all WriteParams_T;
type TypeCode_Access is access all TypeCode;
type TypeObject_Access is access all TypeObject;
type Transport_ClassId_T is new Long;
type TransportInfo_T is record Class_Id : aliased Transport_ClassId_T := 0; Message_Size_Max : aliased Long := 1024; end record with Convention => C;
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.
type TransportInfo_Access is access all TransportInfo_T;
type TransportInfo_Array is array (Natural range <>) of aliased TransportInfo_T with Convention => C;
type ParticipantTrustProtectionInfo is record Bitmask : aliased ParticipantTrustAttributesMask := 0; Plugin_Bitmask : aliased PluginParticipantTrustAttributesMask := 0; end record with Convention => C;
type EndpointTrustProtectionInfo is record Bitmask : aliased EndpointTrustAttributesMask := 0; Plugin_Bitmask : aliased PluginEndpointTrustAttributesMask := 0; end record with Convention => C;
type TrustAlgorithmRequirements is record Supported_Mask : aliased TrustAlgorithmSet := 0; Required_Mask : aliased TrustAlgorithmSet := 0; end record with Convention => C;
type ParticipantTrustSignatureAlgorithmInfo is record Trust_Chain : aliased TrustAlgorithmRequirements; Message_Auth : aliased TrustAlgorithmRequirements; end record with Convention => C;
type ParticipantTrustKeyEstablishmentAlgorithmInfo is record Shared_Secret : aliased TrustAlgorithmRequirements; end record with Convention => C;
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;
type ParticipantTrustAlgorithmInfo is record Signature : aliased ParticipantTrustSignatureAlgorithmInfo; Key_Establishment : aliased ParticipantTrustKeyEstablishmentAlgorithmInfo; Interceptor : aliased ParticipantTrustInterceptorAlgorithmInfo; end record with Convention => C_Pass_By_Copy;
type EndpointTrustInterceptorAlgorithmInfo is record Required_Mask : aliased TrustAlgorithmSet := 0; Supported_Mask : aliased TrustAlgorithmSet := 0; end record with Convention => C_Pass_By_Copy;
type EndpointTrustAlgorithmInfo is record Interceptor : aliased EndpointTrustInterceptorAlgorithmInfo; end record with Convention => C_Pass_By_Copy;
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;
type ParticipantBuiltinTopicData_Access is access all ParticipantBuiltinTopicData;
type ParticipantBuiltinTopicData_Array is array (Natural range <>) of aliased ParticipantBuiltinTopicData;
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;
type TopicBuiltinTopicData_Access is access all TopicBuiltinTopicData;
type TopicBuiltinTopicData_Array is array (Natural range <>) of aliased TopicBuiltinTopicData;
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;
type ServiceRequestInternalTopicData_Access is access all ServiceRequestInternalTopicData;
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;
type PublicationBuiltinTopicData_Access is access all PublicationBuiltinTopicData;
type PublicationBuiltinTopicData_Array is array (Natural range <>) of aliased PublicationBuiltinTopicData;
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;
type SubscriptionBuiltinTopicData_Access is access all SubscriptionBuiltinTopicData;
type SubscriptionBuiltinTopicData_Array is array (Natural range <>) of aliased SubscriptionBuiltinTopicData;
type KeyHash_Value_Array is array (0 .. 15) of aliased DDS.Octet;
type KeyHash_T is record Value : aliased KeyHash_Value_Array := (others => 0); Length : aliased DDS.Unsigned_Long := 0; end record with Convention => C;
type TopicQos_Access is access TopicQos;
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;
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;
type OfferedIncompatibleQosStatus_Access is access all OfferedIncompatibleQosStatus;
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;
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;
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;
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;
type AcknowledgmentInfo_Access is access all AcknowledgmentInfo;
type ServiceRequestAcceptedStatus is new RTIDDS.Low_Level.ndds_dds_c_dds_c_publication_h.DDS_ServiceRequestAcceptedStatus;
type ServiceRequestAcceptedStatus_Access is access all ServiceRequestAcceptedStatus with Storage_Size => 0;
type PublisherQos_Access is access PublisherQos;
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;
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;
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;
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;
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;
type RequestedIncompatibleQosStatus_Access is access all RequestedIncompatibleQosStatus;
type SampleLostStatusKind is new Unsigned_Long;
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;
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);
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
This constant is an extension to the DDS standard.
See also: DDS.DataReaderResourceLimitsQosPolicy
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.
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;
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;
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:
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.
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;
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;
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:
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.
type SampleStateKind is new Unsigned_Long;
For each sample received, the middleware internally maintains a sample_state relative to each DDS.DataReader. The sample state can be either:
The sample state will, in general, be different for each sample in the collection returned by read or take.
subtype SampleStateMask is SampleStateKind;
type SampleStateKind_Access is access constant SampleStateKind;
type ViewStateKind is new Unsigned_Long;
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:
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."
subtype ViewStateMask is ViewStateKind;
type ViewStateKind_Access is access constant ViewStateKind;
type InstanceStateKind is new Unsigned_Long;
For each instance, the middleware internally maintains an instance state. The instance state can be:
The precise behavior events that cause the instance state to change depends on the setting of the OWNERSHIP QoS:
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.
subtype InstanceStateMask is InstanceStateKind;
type InstanceStateKind_Access is access constant InstanceStateKind;
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;
type SampleInfo_Access is access all SampleInfo;
type SampleInfo_Array is array (Natural range <>) of aliased SampleInfo;
type SubscriberQos_Access is access SubscriberQos;
type LogCategory is private;
The NDDSConfigLogger.get_verbosity_by_category and NDDSConfigLogger.set_verbosity_by_category can be used to specify different verbosities for different categories of messages.
type LogVerbosity is private;
type LogPrintFormat is private;
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;
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;
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;
type SqlFilterGeneratorQos is new RTIDDS.Low_Level.ndds_dds_c_dds_c_sqlfilter_h.DDS_SqlFilterGeneratorQos;
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;
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;
type MonitoringPeriodicDistributionSettings is record datawriter_qos_profile_name : aliased String; thread : aliased ThreadSettings_T; polling_period : aliased Duration_T; end record with Convention => C;
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;
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;
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;
type MonitoringMetricSelection_Access is access all MonitoringMetricSelection;
type MonitoringMetricSelection_Array is array (Natural range <>) of aliased MonitoringMetricSelection;
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;
type MonitoringTelemetryData is record logs : aliased MonitoringMetricSelection_Seq.Sequence; metrics : aliased MonitoringLoggingForwardingSettings; end record with Convention => C;
type MonitoringQosPolicy is record enable : aliased Boolean; application_name : aliased String; distribution_settings : aliased MonitoringDistributionSettings; telemetry_data : aliased MonitoringTelemetryData; end record with Convention => C;
type DomainParticipantFactoryQos_Access is access constant DomainParticipantFactoryQos;
type FlowControllerSchedulingPolicy is new Unsigned_Long;
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.
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;
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]
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;
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.
type InvalidLocalIdentityAdvanceNoticeStatus is record Expiration_Time : aliased Time_T; end record with Convention => C;
type ObjectScope is (SIMPLE_OBJECT_SCOPE, CONTAINED_OBJECTS_SCOPE, RELATED_OBJECTS_SCOPE);
type DLRLOid is record Creator_Id : aliased Unsigned_Long; Local_Id : aliased Unsigned_Long; end record;
subtype ClassName is DDS.String;
subtype CacheName is DDS.String;
subtype RelationName is DDS.String;
type ObjectReference is record Oid : DLRLOid; Home_Index : Unsigned_Long; end record;
type RelationKind is (REF_RELATION, LIST_RELATION, INT_MAP_RELATION, STR_MAP_RELATION);
Binding_Version : constant Standard.String := "7.2.0";
NULL_STRING : constant DDS.String := (Data => Interfaces.C.Strings.Null_Ptr);
Default_Domain : constant DomainId_T := 0;
Time_Zero : constant Time_T := (0, 0);
TIME_INVALID_SEC : constant Long_Long := -1;
TIME_INVALID_NSEC : constant Unsigned_Long := 4_294_967_295;
Time_Invalid : constant Time_T := (TIME_INVALID_SEC, TIME_INVALID_NSEC);
DURATION_ZERO_SEC : constant Long := 0;
DURATION_ZERO_NSEC : constant Unsigned_Long := 0;
DURATION_ZERO : Duration_T := (DURATION_ZERO_SEC, DURATION_ZERO_NSEC);
DURATION_INFINITE_SEC : constant Long := 2_147_483_647;
DURATION_INFINITE_NSEC : constant Unsigned_Long := 4_294_967_295;
DURATION_INFINITE : constant Duration_T := (DURATION_INFINITE_SEC, DURATION_INFINITE_NSEC);
DURATION_AUTO_SEC : constant Long := 2_1474_83_647;
DURATION_AUTO_NSEC : constant Unsigned_Long := 0;
DURATION_AUTO : constant Duration_T := (DURATION_AUTO_SEC, DURATION_AUTO_NSEC);
COMPRESSION_SETTINGS_T_DEFAULT : constant CompressionSettings_T := (others => <>);
Null_InstanceHandle_T : aliased constant InstanceHandle_T := InstanceHandle_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_HANDLE_NIL);
HANDLE_NIL : aliased constant InstanceHandle_T := Null_InstanceHandle_T;
Special DDS.InstanceHandle_t value
See also: DDS_InstanceHandle_is_nil
GUID_AUTO : aliased constant Guid_T := (Value => (others => 0));
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.
SEQUENCE_NUMBER_UNKNOWN : constant SequenceNumber_T := (High => -1, Low => 16#FFFF_FFFF#);
SEQUENCE_NUMBER_ZERO : constant SequenceNumber_T := (High => 0, Low => 0);
SEQUENCE_NUMBER_MAX : constant SequenceNumber_T := (High => 2147483647, Low => 16#FFFF_FFFF#);
AUTO_SEQUENCE_NUMBER : constant SequenceNumber_T := (High => -1, Low => 16#FFFF_FFFF#);
ERROR : exception;
Applications are not expected to throw or extend this type, but to handle exceptions of its more-specific subclasses.
UNSUPPORTED : exception;
BAD_PARAMETER : exception;
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 : exception;
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 : exception;
NOT_ENABLED : exception;
IMMUTABLE_POLICY : exception;
INCONSISTENT_POLICY : exception;
ALREADY_DELETED : exception;
NO_DATA : exception;
ILLEGAL_OPERATION : exception;
An operation was invoked on an inappropriate object or at an inappropriate time. This return code is similar to DDS.RETCODE_PRECONDITION_NOT_MET, except that there is no precondition that could be changed to make the operation succeed.
INCONSISTENT_TOPIC_STATUS : constant StatusKind := 2#0000_0000_0000_0001#;
Entity:
DDS.Topic
Status:
DDS.InconsistentTopicStatus
Listener:
DDS.TopicListener
OFFERED_DEADLINE_MISSED_STATUS : constant StatusKind := 2#0000_0000_0000_0010#;
Entity:
DDS.DataWriter
QoS:
DDSDeadlineQosModule
Status:
DDS.OfferedDeadlineMissedStatus
Listener:
DDS.DataWriterListener
REQUESTED_DEADLINE_MISSED_STATUS : constant StatusKind := 2#0000_0000_0000_0100#;
Entity:
DDS.DataReader
QoS:
DDSDeadlineQosModule
Status:
DDS.RequestedDeadlineMissedStatus
Listener:
DDS.DataReaderListener
OFFERED_INCOMPATIBLE_QOS_STATUS : constant StatusKind := 2#0000_0000_0010_0000#;
Entity:
DDS.DataWriter
Status:
DDS.OfferedIncompatibleQosStatus
Listener:
DDS.DataWriterListener
REQUESTED_INCOMPATIBLE_QOS_STATUS : constant StatusKind := 2#0000_0000_0100_0000#;
Entity:
DDS.DataReader
Status:
DDS.RequestedIncompatibleQosStatus
Listener:
DDS.DataReaderListener
SAMPLE_LOST_STATUS : constant StatusKind := 2#0000_0000_1000_0000#;
Entity:
DDS.DataReader
Status:
DDS.SampleLostStatus
Listener:
DDS.DataReaderListener
SAMPLE_REJECTED_STATUS : constant StatusKind := 2#0000_0001_0000_0000#;
Entity:
DDS.DataReader
QoS:
DDSResourceLimitsQosModule
Status:
DDS.SampleRejectedStatus
Listener:
DDS.DataReaderListener
DATA_ON_READERS_STATUS : constant StatusKind := 2#0000_0010_0000_0000#;
Entity:
DDS.Subscriber
Listener:
DDS.SubscriberListener
DATA_AVAILABLE_STATUS : constant StatusKind := 2#0000_0100_0000_0000#;
Entity:
DDS.DataReader
Listener:
DDS.DataReaderListener
LIVELINESS_LOST_STATUS : constant StatusKind := 2#0000_1000_0000_0000#;
Entity:
DDS.DataWriter
QoS:
DDSLivelinessQosModule
Status:
DDS.LivelinessLostStatus
Listener:
DDS.DataWriterListener
LIVELINESS_CHANGED_STATUS : constant StatusKind := 2#0001_0000_0000_0000#;
Entity:
DDS.DataReader
QoS:
DDSLivelinessQosModule
Status:
DDS.LivelinessChangedStatus
Listener:
DDS.DataReaderListener
PUBLICATION_MATCH_STATUS : constant StatusKind := 2#0010_0000_0000_0000#;
Entity:
DDS.DataWriter
Status:
DDS.PublicationMatchedStatus
Listener:
DDS.DataWriterListener
SUBSCRIPTION_MATCH_STATUS : constant StatusKind := 2#0100_0000_0000_0000#;
Entity:
DDS.DataReader
Status:
DDS.SubscriptionMatchedStatus
Listener:
DDS.DataReaderListener
DATA_WRITER_APPLICATION_ACKNOWLEDGMENT_STATUS : constant StatusKind := 2#0000_0000_0100_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0000_0000_1000_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0000_0001_0000_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0000_0010_0000_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0000_0100_0000_0000_0000_0000_0000_0000#;
Changes to this status do not trigger a DDS.StatusCondition.
DATA_WRITER_PROTOCOL_STATUS : constant StatusKind := 2#0000_1000_0000_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0001_0000_0000_0000_0000_0000_0000_0000#;
Changes to this status do not trigger a DDS.StatusCondition.
DATA_READER_PROTOCOL_STATUS : constant StatusKind := 2#0010_0000_0000_0000_0000_0000_0000_0000#;
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 : constant StatusKind := 2#0100_0000_0000_0000_0000_0000_0000_0000#;
DATA_WRITER_SAMPLE_REMOVED_STATUS : constant StatusKind := 2#1000_0000_0000_0000_0000_0000_0000_0000#;
STATUS_MASK_NONE : constant StatusMask := 2#0000_0000_0000_0000_0000_0000_0000_0000#;
STATUS_MASK_ALL : constant StatusMask := 2#1111_1111_1111_1111_1111_1111_1111_1111#;
THREAD_SETTINGS_OPTION_FLOATING_POINT : constant := 16#01#;
Not all of these options may be relevant for all operating systems. Consult Platform Notes for additional details.
See also: DDS.ThreadSettingsKindMask
Currently applicable only for VxWorks platforms, where user callbacks use floating-point operations.
THREAD_SETTINGS_OPTION_STDIO : constant := 16#02#;
Currently applicable only for VxWorks platforms, where user callbacks do standard I/O operations.
THREAD_SETTINGS_OPTION_REALTIME_PRIORITY : constant := 16#08#;
THREAD_SETTINGS_OPTION_PRIORITY_ENFORCE : constant := 16#10#;
THREAD_SETTINGS_OPTION_CANCEL_ASYNCHRONOUS : constant := 16#20#;
THREAD_SETTINGS_KIND_MASK_DEFAULT : constant ThreadSettingsKindMask := THREAD_SETTINGS_OPTION_DEFAULT;
THREAD_SETTINGS_CPU_NO_ROTATION : constant ThreadSettingsCpuRotationKind_T := 0;
THREAD_SETTINGS_CPU_RR_ROTATION : constant ThreadSettingsCpuRotationKind_T := 1;
THREAD_SETTINGS_CPU_ROTATION_DEFAULT : constant ThreadSettingsCpuRotationKind_T := THREAD_SETTINGS_CPU_NO_ROTATION;
QOS_POLICY_COUNT : constant Long := 63;
INVALID_QOS_POLICY_ID : constant QosPolicyId_T := 0;
USERDATA_QOS_POLICY_ID : constant QosPolicyId_T := 1;
DURABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 2;
PRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 3;
DEADLINE_QOS_POLICY_ID : constant QosPolicyId_T := 4;
LATENCYBUDGET_QOS_POLICY_ID : constant QosPolicyId_T := 5;
OWNERSHIP_QOS_POLICY_ID : constant QosPolicyId_T := 6;
OWNERSHIPSTRENGTH_QOS_POLICY_ID : constant QosPolicyId_T := 7;
LIVELINESS_QOS_POLICY_ID : constant QosPolicyId_T := 8;
TIMEBASEDFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 9;
PARTITION_QOS_POLICY_ID : constant QosPolicyId_T := 10;
RELIABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 11;
DESTINATIONORDER_QOS_POLICY_ID : constant QosPolicyId_T := 12;
HISTORY_QOS_POLICY_ID : constant QosPolicyId_T := 13;
RESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 14;
ENTITYFACTORY_QOS_POLICY_ID : constant QosPolicyId_T := 15;
WRITERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 16;
READERDATALIFECYCLE_QOS_POLICY_ID : constant QosPolicyId_T := 17;
TOPICDATA_QOS_POLICY_ID : constant QosPolicyId_T := 18;
GROUPDATA_QOS_POLICY_ID : constant QosPolicyId_T := 19;
TRANSPORTPRIORITY_QOS_POLICY_ID : constant QosPolicyId_T := 20;
LIFESPAN_QOS_POLICY_ID : constant QosPolicyId_T := 21;
DURABILITYSERVICE_QOS_POLICY_ID : constant QosPolicyId_T := 22;
DATA_REPRESENTATION_QOS_POLICY_ID : constant QosPolicyId_T := 23;
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_ID : constant QosPolicyId_T := 24;
DATATAG_QOS_POLICY_ID : constant QosPolicyId_T := 25;
WIREPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1000;
DISCOVERY_QOS_POLICY_ID : constant QosPolicyId_T := 1001;
DATAREADERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1003;
DATAWRITERRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1004;
DATAREADERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1005;
DATAWRITERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1006;
DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1007;
EVENT_QOS_POLICY_ID : constant QosPolicyId_T := 1008;
DATABASE_QOS_POLICY_ID : constant QosPolicyId_T := 1009;
RECEIVERPOOL_QOS_POLICY_ID : constant QosPolicyId_T := 1010;
DISCOVERYCONFIG_QOS_POLICY_ID : constant QosPolicyId_T := 1011;
EXCLUSIVEAREA_QOS_POLICY_ID : constant QosPolicyId_T := 1012;
SYSTEMRESOURCELIMITS_QOS_POLICY_ID : constant QosPolicyId_T := 1014;
TRANSPORTSELECTION_QOS_POLICY_ID : constant QosPolicyId_T := 1015;
TRANSPORTUNICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1016;
TRANSPORTMULTICAST_QOS_POLICY_ID : constant QosPolicyId_T := 1017;
TRANSPORTBUILTIN_QOS_POLICY_ID : constant QosPolicyId_T := 1018;
TYPESUPPORT_QOS_POLICY_ID : constant QosPolicyId_T := 1019;
PROPERTY_QOS_POLICY_ID : constant QosPolicyId_T := 1020;
PUBLISHMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1021;
ASYNCHRONOUSPUBLISHER_QOS_POLICY_ID : constant QosPolicyId_T := 1022;
ENTITYNAME_QOS_POLICY_ID : constant QosPolicyId_T := 1023;
BATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1026;
PROFILE_QOS_POLICY_ID : constant QosPolicyId_T := 1027;
LOCATORFILTER_QOS_POLICY_ID : constant QosPolicyId_T := 1028;
MULTICHANNEL_QOS_POLICY_ID : constant QosPolicyId_T := 1029;
TRANSPORTENCAPSULATION_QOS_POLICY_ID : constant QosPolicyId_T := 1030;
PUBLISHERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1031;
SUBSCRIBERPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1032;
TOPICPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1033;
DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_ID : constant QosPolicyId_T := 1034;
AVAILABILITY_QOS_POLICY_ID : constant QosPolicyId_T := 1035;
TRANSPORTMULTICASTMAPPING_QOS_POLICY_ID : constant QosPolicyId_T := 1036;
LOGGING_QOS_POLICY_ID : constant QosPolicyId_T := 1037;
TOPICQUERYDISPATCH_QOS_POLICY_ID : constant QosPolicyId_T := 1038;
DATAWRITERTRANSFERMODE_QOS_POLICY_ID : constant QosPolicyId_T := 1039;
USERDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserData");
TOPICDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicData");
GROUPDATA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("GroupData");
TOPICPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicProtocol");
TOPIC_PROTOCOL_QOS_POLICY_DEFAULT : constant TopicProtocolQosPolicy := (Vendor_Specific_Entity => False);
DOMAINPARTICIPANTPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantProtocol");
DOMAIN_PARTICIPANT_PROTOCOL_QOS_POLICY_DEFAULT : constant DomainParticipantProtocolQosPolicy := (Vendor_Specific_Entity => False);
BUFFER_POOL_UNLIMITED : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_UNLIMITED;
BUFFER_POOL_AUTO : constant := RTIDDS.Low_Level.ndds_reda_reda_fastBuffer_h.REDA_FAST_BUFFER_POOL_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 : constant AllocationSettings_T := (others => <>);
DURABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Durability");
VOLATILE_DURABILITY_QOS : constant DurabilityQosPolicyKind := 0;
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 : constant DurabilityQosPolicyKind := 1;
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 : constant DurabilityQosPolicyKind := 2;
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 : constant DurabilityQosPolicyKind := 3;
This option requires RTI Persistence Service.
DELETE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 0;
TRUNCATE_PERSISTENT_JOURNAL : constant PersistentJournalKind := 1;
PERSIST_PERSISTENT_JOURNAL : constant PersistentJournalKind := 2;
MEMORY_PERSISTENT_JOURNAL : constant PersistentJournalKind := 3;
WAL_PERSISTENT_JOURNAL : constant PersistentJournalKind := 4;
OFF_PERSISTENT_JOURNAL : constant PersistentJournalKind := 5;
NORMAL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 0;
FULL_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 1;
OFF_PERSISTENT_SYNCHRONIZATION : constant PersistentSynchronizationKind := 2;
PERSISTENT_STORAGE_SETTINGS_DEFAULT : constant PersistentStorageSettings := (others => <>);
DURABILITY_QOS_POLICY_DEFAULT : constant DurabilityQosPolicy := (others => <>);
PRESENTATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Presentation");
INSTANCE_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 0;
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 : constant PresentationQosPolicyAccessScopeKind := 1;
GROUP_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 2;
HIGHEST_OFFERED_PRESENTATION_QOS : constant PresentationQosPolicyAccessScopeKind := 3;
PRESENTATION_QOS_POLICY_DEFAULT : constant PresentationQosPolicy := (others => <>);
DEADLINE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Deadline");
DEADLINE_QOS_POLICY_DEFAULT : constant DeadlineQosPolicy := (Period => DURATION_INFINITE);
LATENCYBUDGET_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LatencyBudget");
LATENCY_BUDGET_QOS_POLICY_DEFAULT : constant LatencyBudgetQosPolicy := (others => <>);
OWNERSHIP_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Ownership");
SHARED_OWNERSHIP_QOS : constant OwnershipQosPolicyKind := 0;
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 : constant OwnershipQosPolicyKind := 1;
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 : constant OwnershipQosPolicy := (others => <>);
OWNERSHIPSTRENGTH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("OwnershipStrength");
OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT : constant OwnershipStrengthQosPolicy := (Value => 0);
LIVELINESS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Liveliness");
AUTOMATIC_LIVELINESS_QOS : constant LivelinessQosPolicyKind := 0;
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 : constant LivelinessQosPolicyKind := 1;
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 : constant LivelinessQosPolicyKind := 2;
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 : constant LivelinessQosPolicy := (others => <>);
TIMEBASEDFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TimeBasedFilter");
TIME_BASED_FILTER_QOS_POLICY_DEFAULT : constant TimeBasedFilterQosPolicy := (others => <>);
PARTITION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Partition");
RELIABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Reliability");
BEST_EFFORT_RELIABILITY_QOS : constant ReliabilityQosPolicyKind := 0;
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 : constant ReliabilityQosPolicyKind := 1;
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 : constant ReliabilityQosPolicyAcknowledgmentModeKind := 0;
Samples are acknowledged according to the Real-Time Publish-Subscribe (RTPS) interoperability protocol.
APPICATION_AUTO_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 1;
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 : constant ReliabilityQosPolicyAcknowledgmentModeKind := 2;
APPICATION_EXPLICIT_ACKNOWLEDGMENT_MODE : constant ReliabilityQosPolicyAcknowledgmentModeKind := 3;
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 : constant ReliabilityQosPolicy := (others => <>);
DESTINATIONORDER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DestinationOrder");
BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyKind := 0;
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 : constant DestinationOrderQosPolicyKind := 1;
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 : constant DestinationOrderQosPolicyScopeKind := 0;
TOPIC_SCOPE_DESTINATIONORDER_QOS : constant DestinationOrderQosPolicyScopeKind := 1;
DESTINATION_ORDER_QOS_POLICY_DEFAULT : constant DestinationOrderQosPolicy := (others => <>);
HISTORY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("History");
KEEP_LAST_HISTORY_QOS : constant HistoryQosPolicyKind := 0;
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 : constant HistoryQosPolicyKind := 1;
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 : constant HistoryQosPolicy := (others => <>);
LENGTH_UNLIMITED : constant Long := -1;
DURABILITYSERVICE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DurabilityService");
DURABILITY_SERVICE_QOS_POLICY_DEFAULT : constant DurabilityServiceQosPolicy := (others => <>);
RESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ResourceLimits");
RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant ResourceLimitsQosPolicy := (others => <>);
TRANSPORTPRIORITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportPriority");
TRANSPORT_PRIORITY_QOS_POLICY_DEFAULT : constant TransportPriorityQosPolicy := (others => <>);
LIFESPAN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Lifespan");
LIFESPAN_QOS_POLICY_DEFAULT : constant LifespanQosPolicy := (others => <>);
WRITERDATALIFECYCLE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("WriterDataLifecycle");
WRITER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant WriterDataLifecycleQosPolicy := (others => <>);
READERDATALIFECYCLE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ReaderDataLifecycle");
READER_DATA_LIFECYCLE_QOS_POLICY_DEFAULT : constant ReaderDataLifecycleQosPolicy := (others => <>);
ENTITYFACTORY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityFactory");
ENTITY_FACTORY_QOS_POLICY_DEFAULT : constant EntityFactoryQosPolicy := (others => <>);
RTPS_RELIABLE_READER_PROTOCOL_DEFAULT : aliased constant RtpsReliableReaderProtocol_T := (others => <>);
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 : aliased constant RtpsReliableReaderProtocol_T := (Max_Heartbeat_Response_Delay => (0, 0), others => <>);
RTPS_RELIABLE_WRITER_PROTOCOL_DEFAULT : constant RtpsReliableWriterProtocol_T := (others => <>);
RTPS_RELIABLE_WRITER_PROTOCOL_DISCOVERY_CONFIG_DEFAULT : constant RtpsReliableWriterProtocol_T := (others => <>);
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 : constant TransportMulticastSettings_T := (others => <>);
TRANSPORT_MULTICAST_MAPPING_FUNCTION_DEFAULT : constant TransportMulticastMappingFunction_T := (others => <>);
TRANSPORT_MULTICAST_MAPPING_DEFAULT : constant TransportMulticastMapping_T := (others => <>);
ENCAPSULATION_ID_CDR_BE : constant EncapsulationId_T := 0;
ENCAPSULATION_ID_CDR_LE : constant EncapsulationId_T := 1;
ENCAPSULATION_ID_CDR_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);
ENCAPSULATION_ID_CDR2_BE : constant EncapsulationId_T := 0;
ENCAPSULATION_ID_CDR2_LE : constant EncapsulationId_T := 1;
ENCAPSULATION_ID_CDR2_NATIVE : constant EncapsulationId_T := System.Bit_Order'Pos (System.Default_Bit_Order);
ENCAPSULATION_ID_SHMEM_REF_PLAIN : EncapsulationId_T := 16#C000#;
ENCAPSULATION_ID_SHMEM_REF_FLAT_DATA : EncapsulationId_T := 16#C001#;
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 : aliased constant DataRepresentationId_T := DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XML_DATA_REPRESENTATION);
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 : aliased constant DataRepresentationId_T := DataRepresentationId_T (RTIDDS.Low_Level.ndds_dds_c_dds_c_infrastructure_h.DDS_XCDR2_DATA_REPRESENTATION);
TRANSPORTSELECTION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportSelection");
TRANSPORT_SELECTION_QOS_POLICY_DEFAULT : constant TransportSelectionQosPolicy := (others => <>);
TRANSPORTUNICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportUnicast");
TRANSPORT_UNICAST_QOS_POLICY_DEFAULT : constant TransportUnicastQosPolicy := (others => <>);
TRANSPORTMULTICAST_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticast");
AUTOMATIC_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 0;
NOTE: This setting is required when using the DDS.TransportMulticastMappingQosPolicy.
UNICAST_ONLY_TRANSPORT_MULTICAST_QOS : constant TransportMulticastQosPolicyKind := 1;
TRANSPORTMULTICASTMAPPING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportMulticastMapping");
TRANSPORTENCAPSULATION_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportEncapsulation");
DISCOVERY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Discovery");
DISCOVERY_QOS_POLICY_DEFAULT : constant DiscoveryQosPolicy := (others => <>);
TRANSPORTBUILTIN_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TransportBuiltin");
TRANSPORTBUILTIN_UDPv4 : constant TransportBuiltinKind := 2 ** 0;
TRANSPORTBUILTIN_SHMEM : constant TransportBuiltinKind := 2 ** 1;
TRANSPORTBUILTIN_INTRA : constant TransportBuiltinKind := 2 ** 2;
TRANSPORTBUILTIN_UDPv6 : constant TransportBuiltinKind := 2 ** 3;
TRANSPORTBUILTIN_INTRA_ALIAS : constant DDS.String := To_DDS_String ("builtin.intra");
TRANSPORTBUILTIN_SHMEM_ALIAS : constant DDS.String := To_DDS_String ("builtin.shmem");
TRANSPORTBUILTIN_UDPv4_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv4");
TRANSPORTBUILTIN_UDPv6_ALIAS : constant DDS.String := To_DDS_String ("builtin.udpv");
TRANSPORTBUILTIN_MASK_NONE : constant TransportBuiltinKindMask := 0;
The user must explictly register transports using NDDSTransportSupport.register_transport.
See also: DDS.TransportBuiltinKindMask
TRANSPORTBUILTIN_MASK_DEFAULT : constant TransportBuiltinKindMask := (TRANSPORTBUILTIN_UDPv4 or TRANSPORTBUILTIN_SHMEM);
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 : constant TransportBuiltinKindMask := 16#FFFF_FFFF#;
See also: DDS.TransportBuiltinKindMask
TRANSPORT_BUILTIN_QOS_POLICY_DEFAULT : constant TransportBuiltinQosPolicy := (Mask => TRANSPORTBUILTIN_MASK_DEFAULT);
RTI_BACKWARDS_COMPATIBLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T := (others => <>);
INTEROPERABLE_RTPS_WELL_KNOWN_PORTS : constant RtpsWellKnownPorts_T := (Domain_Id_Gain => 250, Builtin_Unicast_Port_Offset => 10, User_Unicast_Port_Offset => 11, others => <>);
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 : constant RtpsWellKnownPorts_T := (others => <>);
RTPS_RESERVED_PORT_BUILTIN_UNICAST : constant RtpsReservedPortKind := 2#0001#;
RTPS_RESERVED_PORT_BUILTIN_MULTICAST : constant RtpsReservedPortKind := 2#0010#;
RTPS_RESERVED_PORT_USER_UNICAST : constant RtpsReservedPortKind := 2#0100#;
RTPS_RESERVED_PORT_USER_MULTICAST : constant RtpsReservedPortKind := 2#1000#;
RTPS_RESERVED_PORT_MASK_DEFAULT : constant RtpsReservedPortKindMask := (RTPS_RESERVED_PORT_BUILTIN_UNICAST or RTPS_RESERVED_PORT_BUILTIN_MULTICAST or RTPS_RESERVED_PORT_USER_UNICAST);
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 : constant RtpsReservedPortKindMask := 0;
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 : constant RtpsReservedPortKindMask := 16#FFFF_FFFF#;
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 : constant DDS.String := To_DDS_String ("WireProtocol");
RTPS_AUTO_ID_FROM_IP : constant WireProtocolQosPolicyAutoKind := 0;
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 : constant WireProtocolQosPolicyAutoKind := 1;
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 : constant Unsigned_Long := 0;
WIRE_PROTOCOL_QOS_POLICY_DEFAULT : constant WireProtocolQosPolicy := (others => <>);
LOCATOR_ADDRESS_LENGTH_MAX : constant Unsigned_Long := 16;
LOCATOR_INVALID : constant Locator_T := (Kind => -1, Port => 0, Address => (others => 00), Encapsulations => EncapsulationId_Seq.DEFAULT_SEQUENCE);
LOCATOR_KIND_INVALID : constant Long := -1;
LOCATOR_PORT_INVALID : constant Unsigned_Long := 0;
LOCATOR_ADDRESS_INVALID : constant Locator_Address_Array_T := (others => 0);
LOCATOR_KIND_UDPv4 : constant Long := 1;
LOCATOR_KIND_SHMEM : constant Long := 2;
LOCATOR_KIND_UDPv6 : constant Long := 5;
LOCATOR_KIND_RESERVED : constant Long := 1000;
PROTOCOL_VERSION_DEFAULT : constant ProtocolVersion_T := (others => <>);
PROTOCOLVERSION_1_0 : constant ProtocolVersion_T := (Major => 1, Minor => 0);
PROTOCOLVERSION_1_1 : constant ProtocolVersion_T := (Major => 1, Minor => 1);
PROTOCOLVERSION_1_2 : constant ProtocolVersion_T := (Major => 1, Minor => 2);
PROTOCOLVERSION_2_0 : constant ProtocolVersion_T := (Major => 2, Minor => 0);
PROTOCOLVERSION_2_1 : constant ProtocolVersion_T := (Major => 2, Minor => 1);
PROTOCOLVERSION : constant ProtocolVersion_T := (Major => 2, Minor => 1);
PRODUCTVERSION_UNKNOWN : constant ProductVersion_T := (others => <>);
DATAREADER_RESOURCELIMITS_INSTANCEREPLACEMENT_SETTINGS_DEFAULT : constant DataReaderResourceLimitsInstanceReplacementSettings := (others => <>);
DATAREADERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderResourceLimits");
AUTO_MAX_TOTAL_INSTANCES : constant Long := 0;
DATA_READER_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant DataReaderResourceLimitsQosPolicy := (others => <>);
DATAWRITERRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterResourceLimits");
UNREGISTERED_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 0;
By default, all instance replacement kinds first attempt to reclaim an unregistered, acknowledged instance. Used in DDS.DataWriterResourceLimitsQosPolicy.instance_replacement [default]
ALIVE_INSTANCE_REPLACEMENT : constant DataWriterResourceLimitsInstanceReplacementKind := 1;
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 : constant DataWriterResourceLimitsInstanceReplacementKind := 2;
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 : constant DataWriterResourceLimitsInstanceReplacementKind := 3;
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 : constant DataWriterResourceLimitsInstanceReplacementKind := 4;
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 : constant DataWriterResourceLimitsInstanceReplacementKind := 5;
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 : constant DataWriterResourceLimitsQosPolicy := (others => <>);
SERVICE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Service");
NO_SERVICE_QOS : constant ServiceQosPolicyKind := 0;
PERSISTENCE_SERVICE_QOS : constant ServiceQosPolicyKind := 1;
QUEUING_SERVICE_QOS : constant ServiceQosPolicyKind := 2;
ROUTING_SERVICE_QOS : constant ServiceQosPolicyKind := 3;
RECORDING_SERVICE_QOS : constant ServiceQosPolicyKind := 4;
REPLAY_SERVICE_QOS : constant ServiceQosPolicyKind := 5;
DATABASE_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 6;
DDS_WEB_INTEGRATION_SERVICE_QOS : constant ServiceQosPolicyKind := 7;
SERVICE_QOS_POLICY_DEFAULT : constant ServiceQosPolicy := (others => <>);
PUBLISHERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublisherProtocol");
PUBLISHER_PROTOCOL_QOS_POLICY_DEFAULT : constant PublisherProtocolQosPolicy := (Vendor_Specific_Entity => False);
SUBSCRIBERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SubscriberProtocol");
SUBSCRIBER_PROTOCOL_QOS_POLICY_DEFAULT : constant SubscriberProtocolQosPolicy := (Vendor_Specific_Entity => False);
DATAREADERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataReaderProtocol");
DATA_READER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataReaderProtocolQosPolicy := (others => <>);
DATAWRITERPROTOCOL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterProtocol");
DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT : constant DataWriterProtocolQosPolicy := (others => <>);
SYSTEMRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("SystemResourceLimits");
SYSTEM_RESOURCE_LIMITS_QOS_POLICY_DEFAULT : constant SystemResourceLimitsQosPolicy := (others => <>);
DOMAINPARTICIPANTRESOURCELIMITS_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DomainParticipantResourceLimits");
DomainParticipantResourceLimitsQosPolicy_MATCH_INIT : constant DDS.Long := 32;
NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT : constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 0;
DDS_NOT_ALIVE_FIRST_IGNORED_ENTITY_REPLACEMENT : constant DomainParticipantResourceLimitsIgnoredEntityReplacementKind := 1;
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 : constant DomainParticipantResourceLimitsQosPolicy := (others => <>);
EVENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Event");
EVENT_QOS_POLICY_DEFAULT : constant EventQosPolicy := (others => <>);
DATABASE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Database");
DATABASE_QOS_POLICY_DEFAULT : constant DatabaseQosPolicy := (others => <>);
RECEIVERPOOL_QOS_POLICY_NAME : DDS.String := To_DDS_String ("ReceiverPool");
ReceiverPoolQosPolicy_MAX_RECEIVE_THREADS_DEFAULT : constant Long := -1;
RECEIVER_POOL_QOS_POLICY_DEFAULT : constant ReceiverPoolQosPolicy := (others => <>);
BUILTIN_TOPIC_READER_RESOURCE_LIMITS_DEFAULT : constant BuiltinTopicReaderResourceLimits_T := (others => <>);
BuiltinTopicKey_T_INITIALIZER : constant BuiltinTopicKey_T := (Value => (0, 0, 0, 0));
PUBLISHMODE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("PublishMode");
SYNCHRONOUS_PUBLISH_MODE_QOS : constant PublishModeQosPolicyKind := 0;
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 : constant PublishModeQosPolicyKind := 1;
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 : constant Long := 0;
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 : constant Long := -1;
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 : constant PublishModeQosPolicy := (Kind => SYNCHRONOUS_PUBLISH_MODE_QOS, Flow_Controller_Name => (Data => DDS.NULL_STRING.Data), Priority => PUBLICATION_PRIORITY_UNDEFINED );
DISCOVERYCONFIG_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DiscoveryConfig");
DISCOVERYCONFIG_BUILTIN_SPDP : constant DiscoveryConfigBuiltinPluginKindMask := 2#0001#;
DISCOVERYCONFIG_BUILTIN_SEDP : constant DiscoveryConfigBuiltinPluginKindMask := 2#0010#;
DISCOVERYCONFIG_BUILTIN_SDP : constant DiscoveryConfigBuiltinPluginKindMask := (DISCOVERYCONFIG_BUILTIN_SPDP or DISCOVERYCONFIG_BUILTIN_SEDP);
It is equivalent to SPDP + SEDP.
DISCOVERYCONFIG_BUILTIN_EDS : constant DiscoveryConfigBuiltinPluginKindMask := 2#0100#;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_ALL : constant DiscoveryConfigBuiltinPluginKindMask := 16#EFFF#;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_NONE : constant DiscoveryConfigBuiltinPluginKindMask := 0;
DISCOVERYCONFIG_BUILTIN_PLUGIN_MASK_DEFAULT : constant DiscoveryConfigBuiltinPluginKindMask := DISCOVERYCONFIG_BUILTIN_SDP;
DISCOVERYPLUGIN_DISCOVER_MATCHING_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 1;
DISCOVERYPLUGIN_DISCOVER_ALL_REMOTE_ENTITIES_PROMISCUITY : constant DiscoveryPluginPromiscuityKind := 16#FFFF#;
LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE : constant RemoteParticipantPurgeKind := 0;
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 : constant RemoteParticipantPurgeKind := 1;
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 : constant DiscoveryBuiltinReaderFragmentationResourceLimits_T := (others => <>);
TYPESUPPORT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeSupport");
TYPESUPPORT_QOS_POLICY_DEFAULT : constant TypeSupportQosPolicy := (Plugin_Data => System.Null_Address, Cdr_Padding_Kind => AUTO_CDR_PADDING);
SEMAPHORE_BLOCKING_KIND : constant ThreadBlockingKind := 0;
ASYNCHRONOUSPUBLISHER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("AsynchronousPublisher");
ASYNCHRONOUS_PUBLISHER_QOS_POLICY_DEFAULT : constant AsynchronousPublisherQosPolicy := (others => <>);
DISCOVERY_CONFIG_QOS_POLICY_DEFAULT : constant DiscoveryConfigQosPolicy := (others => <>);
USEROBJECT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("UserObject");
USER_OBJECT_QOS_POLICY_DEFAULT : constant UserObjectQosPolicy := (others => <>);
EXCLUSIVEAREA_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("ExclusiveArea");
EXCLUSIVE_AREA_QOS_POLICY_DEFAULT : constant ExclusiveAreaQosPolicy := (Use_Shared_Exclusive_Area => False, Level => EXCLUSIVE_AREA_AUTO_LEVEL);
DATAWRITERTRANSFERMODE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("DataWriterTransferMode");
DataWriterShmemRefTransferModeSettings_INITIALIZER : constant DataWriterShmemRefTransferModeSettings := (Enable_Data_Consistency_Check => True);
DataWriterTransferModeQosPolicy_INITIALIZER : constant DataWriterTransferModeQosPolicy := (Shmem_Ref_Settings => DataWriterShmemRefTransferModeSettings_INITIALIZER);
TOPIC_QUERY_DISPATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TopicQueryDispatch");
TOPIC_QUERY_DISPATCH_QOS_POLICY_DEFAULT : constant TopicQueryDispatchQosPolicy := (others => <>);
BATCH_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Batch");
BATCH_QOS_POLICY_DEFAULT : constant BatchQosPolicy := (others => <>);
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("TypeConsistencyEnforcement");
DISALLOW_TYPE_COERCION : constant TypeConsistencyKind := 0;
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 : constant TypeConsistencyKind := 1;
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 : constant TypeConsistencyKind := 2;
[default]
TYPE_CONSISTENCY_ENFORCEMENT_QOS_POLICY_DEFAULT : constant TypeConsistencyEnforcementQosPolicy := (others => <>);
LOCATORFILTER_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("LocatorFilter");
LOCATOR_FILTER_QOS_POLICY_DEFAULT : constant LocatorFilterQosPolicy := (others => <>);
MULTICHANNEL_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("MultiChannel");
PROPERTY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Property");
PROPERTY_QOS_POLICY_DEFAULT : constant PropertyQosPolicy := (Value => Property_T_Seq.DEFAULT_SEQUENCE);
AVAILABILITY_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Availability");
CONTENT_FILTER_PROPERTY_DEFAULT : constant ContentFilterProperty_T := (others => <>);
ENTITYNAME_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("EntityName");
ENTITY_NAME_QOS_POLICY_DEFAULT : constant EntityNameQosPolicy := (Name => (Data => DDS.NULL_STRING.Data), Role_Name => (Data => DDS.NULL_STRING.Data));
LOGGING_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Logging");
PROFILE_QOS_POLICY_NAME : constant DDS.String := To_DDS_String ("Profile");
AUTO_SAMPLE_IDENTITY : constant SampleIdentity_T := (Writer_Guid => GUID_AUTO, Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);
Special DDS_AUTO_SAMPLE_IDENTITY value {DDS_GUID_AUTO, DDS_AUTO_SEQUENCE_NUMBER}
UNKNOWN_SAMPLE_IDENTITY : constant SampleIdentity_T := (Writer_Guid => GUID_AUTO, Sequence_Number => SEQUENCE_NUMBER_UNKNOWN);
Special DDS_UNKNOWN_SAMPLE_IDENTITY value {DDS_GUID_UNKNOWN, DDS_SEQUENCE_NUMBER_UNKNOWN}
NULL_SAMPLE_IDENTITY : constant SampleIdentity_T := (Writer_Guid => GUID_UNKNOWN, Sequence_Number => SEQUENCE_NUMBER_ZERO);
Special DDS_UNKNOWN_SAMPLE_IDENTITY value {DDS_GUID_UNKNOWN, DDS_SEQUENCE_NUMBER_UNKNOWN}
COOKIE_DEFAULT : constant Cookie_T := (Value => Octet_Seq.DEFAULT_SEQUENCE);
REDELIVERED_SAMPLE : constant SampleFlagBits := 2#0000_0001#;
INTERMEDIATE_REPLY_SEQUENCE_SAMPLE : constant SampleFlagBits := 2#0000_0010#;
REPLICATE_SAMPLE : constant SampleFlagBits := 2#0000_0100#;
LAST_SHARED_READER_QUEUE_SAMPLE : constant SampleFlagBits := 2#0000_1000#;
INTERMEDIATE_TOPIC_QUERY_SAMPLE : constant SampleFlagBits := 2#0001_0000#;
WRITER_REMOVED_BATCH_SAMPLE : constant SampleFlagBits := 2#0010_0000#;
DISCOVERY_SERVICE_SAMPLE : constant SampleFlagBits := 2#0100_0000#;
WRITEPARAMS_DEFAULT : constant WriteParams_T := (others => <>);
PARTICIPANT_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipant");
Topic name of DDS.ParticipantBuiltinTopicDataDataReader
See also: DDS.ParticipantBuiltinTopicData
See also: DDS.ParticipantBuiltinTopicDataDataReader
PARTICIPANT_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantSecure");
PARTICIPANT_MESSAGE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessage");
PARTICIPANT_MESSAGE_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSParticipantMessageSecure");
PARTICIPANT_PROXY_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantProxy");
PARTICIPANT_STATE_TOPIC_NAME : constant DDS.String := To_DDS_String ("DDSParticipantState");
ParticipantBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PARTICIPANT_TYPE_NAME);
ParticipantBuiltinTopicData_INITIALIZER : constant ParticipantBuiltinTopicData := (others => <>);
TOPIC_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSTopic");
Topic name of DDS.TopicBuiltinTopicDataDataReader
See also: DDS.TopicBuiltinTopicData
See also: DDS.TopicBuiltinTopicDataDataReader
TopicBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_TOPIC_TYPE_NAME);
TopicBuiltinTopicData_INITIALIZER : constant TopicBuiltinTopicData := (others => <>);
PUBLICATION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublication");
Topic name of DDS.PublicationBuiltinTopicDataDataReader
See also: DDS.PublicationBuiltinTopicData
See also: DDS.PublicationBuiltinTopicDataDataReader
PUBLICATION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSPublicationSecure");
PublicationBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_PUBLICATION_TYPE_NAME);
SUBSCRIPTION_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscription");
Topic name of DDS.SubscriptionBuiltinTopicDataDataReader
See also: DDS.SubscriptionBuiltinTopicData
See also: DDS.SubscriptionBuiltinTopicDataDataReader
SUBSCRIPTION_TRUSTED_TOPIC_NAME : constant DDS.String := To_DDS_String ("DCPSSubscriptionSecure");
SubscriptionBuiltinTopicData_TypeName : DDS.String := (Data => RTIDDS.Low_Level.ndds_dds_c_dds_c_builtin_impl_h.DDS_SUBSCRIPTION_TYPE_NAME);
InconsistentTopicStatus_INITIALIZER : constant InconsistentTopicStatus := (others => <>);
OfferedDeadlineMissedStatus_INITIALIZER : constant OfferedDeadlineMissedStatus := (others => <>);
LivelinessLostStatus_INITIALIZER : constant LivelinessLostStatus := (others => <>);
OfferedIncompatibleQosStatus_INITIALIZER : constant OfferedIncompatibleQosStatus := (others => <>);
PublicationMatchedStatus_INITIALIZER : constant PublicationMatchedStatus := (others => <>);
ReliableWriterCacheEventCount_INITIALIZER : constant ReliableWriterCacheEventCount := (others => <>);
ReliableWriterCacheChangedStatus_INITIALIZER : constant ReliableWriterCacheChangedStatus := (others => <>);
ReliableReaderActivityChangedStatus_INITIALIZER : constant ReliableReaderActivityChangedStatus := (others => <>);
RequestedDeadlineMissedStatus_INITIALIZER : constant RequestedDeadlineMissedStatus := (others => <>);
LivelinessChangedStatus_INITIALIZER : constant LivelinessChangedStatus := (others => <>);
RequestedIncompatibleQosStatus_INITIALIZER : constant RequestedIncompatibleQosStatus := (others => <>);
NOT_LOST : constant SampleLostStatusKind := 0;
This constant is an extension to the DDS standard.
LOST_BY_WRITER : constant SampleLostStatusKind := 1;
This constant is an extension to the DDS standard.
LOST_BY_INSTANCES_LIMIT : constant SampleLostStatusKind := 2;
This constant is an extension to the DDS standard.
See also: DDS.ResourceLimitsQosPolicy
LOST_BY_REMOTE_WRITERS_PER_INSTANCE_LIMIT : constant SampleLostStatusKind := 3;
This constant is an extension to the DDS standard.
See also: DDS.DataReaderResourceLimitsQosPolicy
LOST_BY_INCOMPLETE_COHERENT_SET : constant SampleLostStatusKind := 4;
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 : constant SampleLostStatusKind := 5;
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 : constant SampleLostStatusKind := 6;
This constant is an extension to the DDS standard.
See also: DDS.DataReaderResourceLimitsQosPolicy
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 : 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 : 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 : 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 : 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 : 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 : constant SampleLostStatus := (others => <>);
SampleRejectedStatus_INITIALIZER : constant SampleRejectedStatus := (others => <>);
SubscriptionMatchedStatus_INITIALIZER : constant SubscriptionMatchedStatus := (others => <>);
DataReaderCacheStatus_INITIALIZER : constant DataReaderCacheStatus := (others => <>);
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 : constant SampleStateKind := 1;
NOT_READ_SAMPLE_STATE : constant SampleStateKind := 2;
ANY_SAMPLE_STATE : constant SampleStateMask := 16#FFFF#;
NEW_VIEW_STATE : constant ViewStateKind := 1;
NOT_NEW_VIEW_STATE : constant ViewStateKind := 2;
ANY_VIEW_STATE : constant ViewStateMask := 16#FFFF#;
ALIVE_INSTANCE_STATE : constant InstanceStateKind := 1;
NOT_ALIVE_DISPOSED_INSTANCE_STATE : constant InstanceStateKind := 2;
NOT_ALIVE_NO_WRITERS_INSTANCE_STATE : constant InstanceStateKind := 4;
NOT_ALIVE_INSTANCE_STATE : constant InstanceStateMask := 6;
ANY_INSTANCE_STATE : constant InstanceStateMask := 16#FFFF#;
SQLFILTER_NAME : constant DDS.String := To_DDS_String ("DDSSQL");
See also: DDSQueryAndFilterSyntaxModule
STRINGMATCHFILTER_NAME : constant DDS.String := To_DDS_String ("DDSSTRINGMATCH");
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 : constant LogCategory;
Category_COMMUNICATION : constant LogCategory;
Category_DATABASE : constant LogCategory;
Category_ENTITIES : constant LogCategory;
Category_API : constant LogCategory;
Category_ALL : constant LogCategory;
VERBOSITY_SILENT : constant LogVerbosity;
VERBOSITY_ERROR : constant LogVerbosity;
An error indicates something wrong in the functioning of dds. The most common cause of errors is incorrect configuration.
VERBOSITY_WARNING : constant LogVerbosity;
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 : constant LogVerbosity;
VERBOSITY_STATUS_REMOTE : constant LogVerbosity;
VERBOSITY_ALL : constant LogVerbosity;
PRINT_NONE : constant LogPrintFormat;
PRINT_FORMAT_DEFAULT : constant LogPrintFormat;
PRINT_FORMAT_TIMESTAMPED : constant LogPrintFormat;
PRINT_FORMAT_VERBOSE : constant LogPrintFormat;
PRINT_FORMAT_VERBOSE_TIMESTAMPED : constant LogPrintFormat;
PRINT_FORMAT_DEBUG : constant LogPrintFormat;
PRINT_FORMAT_MINIMAL : constant LogPrintFormat;
PRINT_FORMAT_MAXIMAL : constant LogPrintFormat;
DEFAULT_FLOW_CONTROLLER_NAME : constant DDS.String := To_DDS_String ("DDS_DEFAULT_FLOW_CONTROLLER_NAME");
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 : constant DDS.String := To_DDS_String ("DDS_FIXED_RATE_FLOW_CONTROLLER_NAME");
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 : constant DDS.String := To_DDS_String ("DDS_ON_DEMAND_FLOW_CONTROLLER_NAME");
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 : constant FlowControllerSchedulingPolicy := 0;
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 : constant FlowControllerSchedulingPolicy := 1;
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 : constant FlowControllerProperty_T := (Scheduling_Policy => DDS.EDF_FLOW_CONTROLLER_SCHED_POLICY, Token_Bucket => (-1, -1, 0, (1, 0), -1), Is_Vendor_Specific => False);
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 : constant ObjectSubState := 2#0000_0000_0000_0001#;
OBJECT_MODIFIED : constant ObjectSubState := 2#0000_0000_0000_0010#;
OBJECT_READ : constant ObjectSubState := 2#0000_0000_0000_0100#;
OBJECT_DELETED : constant ObjectSubState := 2#0000_0000_0000_1000#;
OBJECT_CREATED : constant ObjectSubState := 2#0000_0001_0000_0000#;
OBJECT_CHANGED : constant ObjectSubState := 2#0000_0010_0000_0000#;
OBJECT_WRITTEN : constant ObjectSubState := 2#0000_0100_0000_0000#;
OBJECT_DESTROYED : constant ObjectSubState := 2#0000_1000_0000_0000#;
INFINITE_TIME_OUT : constant TimeOutDuration := -1;
UNLIMITED_RELATED_OBJECTS : constant RelatedObjectDepth := -1;
function Image
( | Item | : Octet) return Standard.String; |
An 8-bit quantity that is guaranteed not to undergo any conversion when transmitted by the middleware.
function "="
( | L | : DDS.String; |
R | : Standard.String) return Standard.Boolean; |
function "="
( | L | : Standard.String; |
R | : DDS.String) return Standard.Boolean; |
function "&"
( | L | : DDS.String; |
R | : Standard.String) return Standard.String; |
function "&"
( | L | : Standard.String; |
R | : DDS.String) return Standard.String; |
procedure Append
( | To | : in out DDS.String; |
Data | : DDS.String); |
procedure Append
( | To | : in out DDS.String; |
Data | : Standard.String); |
procedure Prepend
( | To | : in out DDS.String; |
Data | : DDS.String); |
procedure Prepend
( | To | : in out DDS.String; |
Data | : Standard.String); |
function WValue
( | Item | : Wchars_Ptr) return Interfaces.C.char16_array; |
function "+"
( | Left | : Wchars_Ptr; |
Right | : Interfaces.C.size_t) return Wchars_Ptr; |
function Peek
( | From | : Wchars_Ptr) return Standard.Wide_Character; |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Unsigned_Short, Unsigned_Short_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Unsigned_Long, Unsigned_Long_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Unsigned_Long_Long, Unsigned_Long_Long_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Double, Double_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Long_Double, Long_Double_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Boolean, Boolean_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | String, String_Ptr); |
procedure Deallocate is new Ada.Unchecked_Deallocation
( | Wide_String, Wide_String_Ptr); |
procedure Initialize
( | Self | : in out Short); |
procedure Finalize
( | Self | : in out Short); |
procedure Initialize
( | Self | : in out Long); |
procedure Finalize
( | Self | : in out Long); |
procedure Initialize
( | Self | : in out Long_Long); |
procedure Finalize
( | Self | : in out Long_Long); |
procedure Initialize
( | Self | : in out Unsigned_Short); |
procedure Finalize
( | Self | : in out Unsigned_Short); |
procedure Copy
( | Dst | : in out Unsigned_Short; |
Src | : in Unsigned_Short); |
procedure Initialize
( | Self | : in out Unsigned_Long); |
procedure Finalize
( | Self | : in out Unsigned_Long); |
procedure Copy
( | Dst | : in out Unsigned_Long; |
Src | : in Unsigned_Long); |
procedure Initialize
( | Self | : in out Unsigned_Long_Long); |
procedure Finalize
( | Self | : in out Unsigned_Long_Long); |
procedure Copy
( | Dst | : in out Unsigned_Long_Long; |
Src | : in Unsigned_Long_Long); |
procedure Initialize
( | Self | : in out Enum); |
procedure Finalize
( | Self | : in out Enum); |
procedure Initialize
( | Self | : in out Float); |
procedure Finalize
( | Self | : in out Float); |
procedure Initialize
( | Self | : in out Double); |
procedure Finalize
( | Self | : in out Double); |
procedure Initialize
( | Self | : in out Long_Double); |
procedure Finalize
( | Self | : in out Long_Double); |
procedure Copy
( | Dst | : in out Long_Double; |
Src | : in Long_Double); |
procedure Initialize
( | Self | : in out Char); |
procedure Finalize
( | Self | : in out Char); |
procedure Initialize
( | Self | : in out Wchar); |
procedure Finalize
( | Self | : in out Wchar); |
procedure Initialize
( | Self | : in out Octet); |
procedure Finalize
( | Self | : in out Octet); |
function Octets_Of
( | Item | : Octet_Seq.Sequence) return Octets is (Octets'(Length => Item.Length, Value => Item.Contiguous_Buffer.all'Address)); |
procedure Initialize
( | Self | : in out Octets); |
procedure Finalize
( | Self | : in out Octets); |
procedure Initialize
( | Self | : in out Boolean); |
procedure Finalize
( | Self | : in out Boolean); |
function To_DDS_String
( | Source | : Standard.String) return DDS.String is (Data => Interfaces.C.Strings.New_String (Source)); |
function To_Standard_String
( | Source | : DDS.String) return Standard.String; |
procedure Copy
( | Dst | : in out DDS.String; |
Src | : in Standard.String); |
procedure Copy
( | Dst | : in out Standard.String; |
Src | : in DDS.String); |
function "="
( | L, R | : DDS.String) return Boolean; |
procedure Initialize
( | Self | : in out DDS.String); |
procedure Finalize
( | Self | : in out DDS.String); |
procedure Copy
( | Dst | : in out DDS.String; |
Src | : in DDS.String); |
function To_DDS_KeyedString
( | Key | : Standard.String; |
Source | : Standard.String) return DDS.KeyedString; |
function To_Standard_String
( | Source | : DDS.KeyedString) return Standard.String; |
function Get_Key_From_KeyedString
( | Source | : DDS.KeyedString) return Standard.String; |
function "="
( | L, R | : DDS.KeyedString) return Boolean; |
procedure Initialize
( | Self | : in out DDS.KeyedString); |
procedure Finalize
( | Self | : in out DDS.KeyedString); |
procedure Copy
( | Dst | : in out DDS.KeyedString; |
Src | : in DDS.KeyedString); |
function KeyedString_Of
( | Value | : DDS.String; |
Key | : DDS.String) return KeyedString; |
function KeyedString_Of
( | Key | : DDS.String) return KeyedString; |
function KeyedString_Of
( | Value | : Standard.String; |
Key | : Standard.String) return KeyedString; |
function KeyedString_Of
( | Key | : Standard.String) return KeyedString; |
procedure Initialize
( | Self | : in out DDS.KeyedOctets); |
procedure Finalize
( | Self | : in out DDS.KeyedOctets); |
procedure Copy
( | Dst | : in out DDS.KeyedOctets; |
Src | : in DDS.KeyedOctets); |
function KeyedOctets_Of
( | Key | : String; |
Value | : Octets := Null_Octets) return KeyedOctets; |
function KeyedOctets_Of
( | Key | : String; |
Value | : Octet_Array) return KeyedOctets; |
function KeyedOctets_Of
( | Key | : String; |
Value | : Octet_Seq.Sequence) return KeyedOctets; |
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); Time_Is_Zero
Summary: Check if time is zeroReturns: DDS.BOOLEAN_TRUE if the given time is equal to DDS_TIME_ZERO or DDS.BOOLEAN_FALSE otherwise.
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; +
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); 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_NILReturns: DDS.BOOLEAN_TRUE if the given instance handle is equal to DDS_HANDLE_NIL or DDS.BOOLEAN_FALSE otherwise.
See also: DDS_InstanceHandle_equalsHash
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 GUIDsself: <<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); 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); Copy
procedure Copy
( Dst : in out TransportUnicastSettings_T; Src : in TransportUnicastSettings_T); Initialize
procedure Initialize
( Self : in out TransportMulticastSettings_T); Finalize
procedure Finalize
( Self : in out TransportMulticastSettings_T); Copy
procedure Copy
( Dst : in out TransportMulticastSettings_T; Src : in TransportMulticastSettings_T); Initialize
procedure Initialize
( Self : in out TransportMulticastMapping_T); Finalize
procedure Finalize
( Self : in out TransportMulticastMapping_T); Copy
procedure Copy
( Dst : in out TransportMulticastMapping_T; Src : in 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); Copy
procedure Copy
( Dst : in out TransportEncapsulationSettings_T; Src : in 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; =
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); Copy
procedure Copy
( Dst : in out Discovery_ParticipantInformation; Src : in Discovery_ParticipantInformation); Initialize
procedure Initialize
( Self : in out Discovery_EndpointInformation); Finalize
procedure Finalize
( Self : in out Discovery_EndpointInformation); Copy
procedure Copy
( Dst : in out Discovery_EndpointInformation; Src : in Discovery_EndpointInformation); Initialize
procedure Initialize
( Self : in out Locator_T); Finalize
procedure Finalize
( Self : in out 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 : Standard.String) return Standard.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); 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; 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); Copy
procedure Copy
( Dst : in out ParticipantBuiltinTopicData; Src : in 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); Copy
procedure Copy
( Dst : in out PublicationBuiltinTopicData; Src : in 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.SubscriptionBuiltinTopicDataDataReaderData 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_tService: <<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); Copy
procedure Copy
( Dst : in out SubscriptionBuiltinTopicData; Src : in 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.finalizeFinalize
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.initializeCopy
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.finalizeInitialize
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.finalizeFinalize
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.initializeCopy
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.finalizeInitialize
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.finalizeFinalize
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.initializeCopy
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.finalizeInitialize
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.finalizeFinalize
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.finalizeFinalize
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.finalizeFinalize
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.initializeCopy
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.finalizeInitialize
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.finalizeFinalize
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.initializeCopy
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
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).
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
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 := "");