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

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

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

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

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

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

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

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

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

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

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

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

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

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

StringSeq is a sequence that contains strings.

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

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

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

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

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

Instantiates:
<<generic>> FooSeq

See also: DDS.QosPolicyCount

See also: DDS.Tag

Instantiates:
<<generic>> FooSeq

See also: DDS.TransportUnicastSettings_t

Instantiates:
<<generic>> FooSeq

See also: DDS.TransportMulticastSettings_t

Instantiates:
<<generic>> FooSeq

See also: DDS.TransportMulticastMapping_t

See also: DDS.DataRepresentationId_t

See also: DDS.Locator_t

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

Instantiates:
<<generic>> FooSeq

See also: DDS.LocatorFilter_t

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

See also: DDS.Property_t

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

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

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

See also: FooSeq

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

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

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

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

See also: FooSeq

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.

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.

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.

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.

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.

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.

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.

A 16-bit signed short integer value.

A 32-bit signed long integer value.

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.

A 32-bit floating-point value.

A 64-bit floating-point value.

A 128-bit floating-point value.

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

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

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

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

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

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)

A DDS.Time_t represents a moment in time.

Sec: seconds

Nanosec: nanoseconds

[range] [0,1000000000)

Represents a time interval.

Sec: seconds

Nanosec: nanoseconds

[range] [0,1000000000)

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.

Represents a 64-bit sequence number.

High: The most significant part of the sequence number

Low: The least significant part of the sequence number

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

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.

See also: DDS.ThreadSettings_t

Controlling CPU Core Affinity for RTI Threads

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.

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.

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

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

See also: DDS.DomainParticipant.get_builtin_subscriber

Usage

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]

Entity:
DDS.DataReader DDS.DataWriter

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

Usage

Entity:
DDS.Publisher, DDS.Subscriber

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

See also: DDS.DomainParticipant.get_builtin_subscriber

Usage

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]

QoS:
DDS.DurabilityQosPolicy

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

QoS:
DDS.DurabilityQosPolicy

QoS:
DDS.DurabilityQosPolicy

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

QoS:
DDS.PresentationQosPolicy

QoS:
DDS.OwnershipQosPolicy

QoS:
DDS.LivelinessQosPolicy

QoS:
DDS.ReliabilityQosPolicy

QoS:
DDS.ReliabilityQosPolicy

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.

QoS:
DDS.DestinationOrderQosPolicy

QoS:
DDS.HistoryQosPolicy

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.

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]

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.

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.

See also: DDS.TransportMulticastQosPolicy

Entity:
DDS.DomainParticipant

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

Usage

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

See also: DDS.TransportBuiltinKindMask

QoS:
DDS.TransportBuiltinQosPolicy

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

(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:

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.

See also: DDS.WireProtocolQosPolicy.rtps_reserved_port_mask

QoS:
DDS.WireProtocolQosPolicy

See also: DDS.WireProtocolQosPolicy.rtps_auto_id_kind

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.

Major: Major protocol version number

Minor: Minor protocol version number

VendorId: The vendor Id.

Major: Major product version.

Minor: Minor product version.

Release: Release letter for product version.

Revision: Revision number of product.

[default]

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

See also: DDS.DataReaderResourceLimitsQosPolicy.instance_replacement

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

[default] DDS.NO_INSTANCE_REMOVAL

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

[default] DDS.EMPTY_INSTANCE_REMOVAL

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

[default] DDS.EMPTY_INSTANCE_REMOVAL

When DDS.ResourceLimitsQosPolicy.max_instances is reached, a DDS.DataWriter will try to make room for a new instance by attempting to reclaim an existing instance based on the instance replacement kind specified by DDS.DataWriterResourceLimitsQosPolicy.instance_replacement.

Only instances whose states match the specified kinds are eligible to be replaced. In addition, an instance must have had all of its samples fully acknowledged for it to be considered replaceable.

For all kinds, a DDS.DataWriter will replace the oldest instance satisfying that kind. For example, when the kind is DDS.UNREGISTERED_INSTANCE_REPLACEMENT, a DDS.DataWriter will remove the oldest, fully acknowledged, unregistered instance, if such an instance exists.

If no replaceable instance exists, the invoked function will either return with an appropriate out-of-resources return code, or in the case of a write, it may first block to wait for an instance to be acknowledged. Otherwise, the DDS.DataWriter will replace the old instance with the new instance, and invoke, if available, the DDS.DataWriterListener.on_instance_replaced to notify the user about an instance being replaced.

A DDS.DataWriter checks for replaceable instances in the following order, stopping once a replaceable instance is found:

• If DDS.DataWriterResourceLimitsQosPolicy.replace_empty_instances is DDS.BOOLEAN_TRUE, a DDS.DataWriter first tries replacing instances that have no samples. These empty instances can be unregistered, disposed, or alive.
• Next, a DDS.DataWriter tries replacing unregistered instances. Since an unregistered instance indicates that the DDS.DataWriter is done modifying it, unregistered instances are replaced before instances of any other state (alive, disposed). This is the same as the DDS.UNREGISTERED_INSTANCE_REPLACEMENT kind.
• Then, a DDS.DataWriter tries replacing what is specified by DDS.DataWriterResourceLimitsQosPolicy.instance_replacement. With unregistered instances already checked, this leaves alive and disposed instances. When both alive and disposed instances may be replaced, the kind specifies whether the particular order matters (e.g., DISPOSED_THEN_ALIVE, ALIVE_THEN_DISPOSED) or not (ALIVE_OR_DISPOSED).

QoS:
DDS.DataWriterResourceLimitsQosPolicy

QoS:
DDS.ServiceQosPolicy

QoS:
DDS.DomainParticipantResourceLimitsQosPolicy