Setting DataReader QosPolicies

A DataReader’s QosPolicies control its behavior. This of QosPolicies as the 'properties' of a DataReader.

The DDS_DataReaderQos structure has the following format:

DDS_DataWriterQos struct  {
	DDS_DurabilityQosPolicy			durability; 
	DDS_DeadlineQosPolicy			deadline; 
	DDS_LatencyBudgetQosPolicy		latency_budget; 
	DDS_LivelinessQosPolicy			liveliness; 
	DDS_ReliabilityQosPolicy		reliability; 
	DDS_DestinationOrderQosPolicy		destination_order; 
	DDS_HistoryQosPolicy  			history; 
	DDS_ResourceLimitsQosPolicy  		resource_limits; 
	DDS_UserDataQosPolicy  			user_data;
	DDS_OwnershipQosPolicy			ownership;
	DDS_TimeBasedFilterQosPolicy		time_based_filter;  
	DDS_ReaderDataLifecycleQosPolicy  	reader_data_lifecycle;
	DDS_TypeConsistencyEnforcementQosPolicy	type_consistency;
	// extensions to the DDS standard: 
	DDS_DataReaderResourceLimitsQosPolicy	reader_resource_limits; 
	DDS_DataReaderProtocolQosPolicy  	protocol; 
	DDS_TransportSelectionQosPolicy  	transport_selection;
	DDS_TransportUnicastQosPolicy		unicast;
	DDS_TransportMulticastQosPolicy		multicast; 
	DDS_PropertyQosPolicy			property;
	DDS_ServiceQosPolicy			service;
	DDS_AvailabilityQosPolicy		availability;
	DDS_EntityNameQosPolicy			subscription_name;
	DDS_TransportPriorotyQosPolicy		transport_priority;
	DDS_TypeSupportQosPolicy		type_support;
} DDS_DataReaderQos;

Note: set_qos() cannot always be used within a listener callback, see Restricted Operations in Listener Callbacks.

DataReader QosPolicies summarizes the meaning of each policy. (They appear alphabetically in the table.) For information on why you would want to change a particular QosPolicy, see the referenced section. For defaults and valid ranges, please refer to the API Reference HTML documentation.

For a DataReader to communicate with a DataWriter, their corresponding QosPolicies must be compatible. For QosPolicies that apply both to the DataWriter and the DataReader, the setting in the DataWriter is considered what the DataWriter “offers” and the setting in the DataReader is what the DataReader “requests.” Compatibility means that what is offered by the DataWriter equals or surpasses what is requested by the DataReader. See QoS Requested vs. Offered Compatibility—the RxO Property.

Some of the policies may be changed after the DataReader has been created. This allows the application to modify the behavior of the DataReader while it is in use. To modify the QoS of an already-created DataReader, use the get_qos() and set_qos() operations on the DataReader. This is a general pattern for all Entities, described in Changing the QoS for an Existing Entity.

Configuring QoS Settings when the DataReader is Created

As described in Creating DataReaders, there are different ways to create a DataReader, depending on how you want to specify its QoS (with or without a QoS Profile).

• In Figure: Creating a DataReader with Default QosPolicies , there is an example of how to create a DataReader with default QosPolicies by using the special constant, DDS_DATAREADER_QOS_DEFAULT, which indicates that the default QoS values for a DataReader should be used. The default DataReader QoS values are configured in the Subscriber or DomainParticipant; you can change them with set_default_datareader_qos() or set_default_datareader_qos_with_profile(). Then any DataReaders created with the Subscriber will use the new default values. As described in Getting, Setting, and Comparing QosPolicies, this is a general pattern that applies to the construction of all Entities.
• To create a DataReader with non-default QoS without using a QoS Profile, see the example code in Figure: Creating a DataReader with Modified QosPolicies (not from a profile). It uses the Subscriber’s get_default_reader_qos() method to initialize a DDS_DataReaderQos structure. Then the policies are modified from their default values before the structure is used in the create_datareader() method.
• You can also create a DataReader and specify its QoS settings via a QoS Profile. To do so, you will call create_datareader_with_profile(), as seen in Figure: Creating a DataReader with a QoS Profile.
• If you want to use a QoS profile, but then make some changes to the QoS before creating the DataReader, call get_datawriter_qos_from_profile() and create_datawriter() as seen in Figure: Getting QoS Values from Profile, Changing QoS Values, Creating DataReader with Modified QoS Values.

For more information, see Creating DataWriters and Configuring QoS with XML.

DDS_DataReaderQos reader_qos;2Note: In C, you must initialize the QoS structures before they are used, see Special QosPolicy Handling Considerations for C (Section on page 1).
// initialize reader_qos with default values
subscriber->get_default_datareader_qos(reader_qos);
// make QoS changes
reader_qos.history.depth = 5;
// Create the reader with modified qos
DDSDataReader * reader = subscriber->create_datareader(
    topic, reader_qos, NULL, DDS_STATUS_MASK_NONE);
if (writer == NULL) {
    // ... error
}
// narrow it for your specific data type
FooDataReader* foo_reader = FooDataReader::narrow(reader);

// Create the datawriter
DDSDataWriter * writer =
    publisher->create_datawriter_with_profile(
        topic, “MyWriterLibrary”, “MyWriterProfile”,
        NULL, DDS_STATUS_MASK_NONE);
if (writer == NULL) {
    // ... error
};
// narrow it for your specific data type
FooDataWriter* foo_writer = FooDataWriter::narrow(writer);

DDS_DataReaderQos reader_qos;3Note: In C, you must initialize the QoS structures before they are used, see Special QosPolicy Handling Considerations for C (Section on page 1).
// Get reader QoS from profile
retcode = factory->get_datareader_qos_from_profile(
    reader_qos, “ReaderProfileLibrary”, “ReaderProfile”);
if (retcode != DDS_RETCODE_OK) {
    // handle error
}
// Makes QoS changes
reader_qos.history.depth = 5;
DDSDataReader * reader = subscriber->create_datareader(
    topic, reader_qos, NULL, DDS_STATUS_MASK_NONE);
if (participant == NULL) {
    // handle error
}

Comparing QoS Values

The equals() operation compares two DataReader’s DDS_DataReaderQoS structures for equality. It takes two parameters for the two DataReader’s QoS structures to be compared, then returns TRUE is they are equal (all values are the same) or FALSE if they are not equal.

Changing QoS Settings After the DataReader has been Created

There are two ways to change an existing DataReader’s QoS after it is has been created—again depending on whether or not you are using a QoS Profile.

• To change QoS programmatically (that is, without using a QoS Profile), use get_qos() and set_qos(). See the example code in Figure: Changing the QoS of Existing DataReader (without a QoS Profile). It retrieves the current values by calling the DataWriter’s get_qos() operation. Then it modifies the value and calls set_qos() to apply the new value. Note, however, that some QosPolicies cannot be changed after the DataWriter has been enabled—this restriction is noted in the descriptions of the individual QosPolicies.
• You can also change a DataReader’s (and all other Entities’) QoS by using a QoS Profile and calling set_qos_with_profile(). For an example, see Figure: Changing the QoS of Existing DataReader with a QoS Profile . For more information, see Configuring QoS with XML.

DDS_DataReaderQos reader_qos;4Note: In C, you must initialize the QoS structures before they are used, see Special QosPolicy Handling Considerations for C.
// Get current QoS.
if (datareader->get_qos(reader_qos) != DDS_RETCODE_OK) {
    // handle error
}
// Makes QoS changes here
reader_qos.history.depth = 5;
// Set the new QoS
if (datareader->set_qos(reader_qos) != DDS_RETCODE_OK ) {
    // handle error
}

retcode = reader->set_qos_with_profile(
    “ReaderProfileLibrary”,”ReaderProfile”);
if (retcode != DDS_RETCODE_OK) {
    // handle error
}

Using a Topic’s QoS to Initialize a DataReader’s QoS

Several DataReader QosPolicies can also be found in the QosPolicies for Topics (see Setting Topic QosPolicies). The QosPolicies set in the Topic do not directly affect the DataReaders (or DataWriters) that use that Topic. In many ways, some QosPolicies are a Topic-level concept, even though the DDS standard allows you to set different values for those policies for different DataWriters and DataReaders of the same Topic. Thus, the policies in the DDS_TopicQos structure exist as a way to help centralize and annotate the intended or suggested values of those QosPolicies. Connext DDS does not check to see if the actual policies set for a DataReader is aligned with those set in the Topic to which it is bound.

There are many ways to use the QosPolicies’ values set in the Topic when setting the QosPolicies’ values in a DataReader. The most straightforward way is to get the values of policies directly from the Topic and use them in the policies for the DataReader, as shown in Figure: Copying Selected QoS from a Topic when Creating a DataReader.

DDS_DataReaderQos reader_qos;5Note: In C, you must initialize the QoS structures before they are used, see Special QosPolicy Handling Considerations for C.
DDS_TopicQos topic_qos;
// topic and publisher already created
// get current QoS for the topic, default QoS for the reader
if (topic->get_qos(topic_qos) != DDS_RETCODE_OK) {
    // handle error
}
if (publisher->get_default_datareader_qos(reader_qos) 
    != DDS_RETCODE_OK) {
    // handle error
}
// Copy specific policies from topic QoS to reader QoS
reader_qos.deadline = topic_qos.deadline;
reader_qos.reliability = topic_qos.reliability;
// Create the DataReader with the modified QoS
DDSDataReader* reader = publisher->create_datareader(topic,
   reader_qos,NULL, DDS_STATUS_MASK_NONE);

DDS_DataReaderQos reader_qos;6Note: In C, you must initialize the QoS structures before they are used, see Special QosPolicy Handling Considerations for C.
DDS_TopicQos topic_qos;
// topic, publisher, reader_listener already created
if (topic->get_qos(topic_qos) != DDS_RETCODE_OK) {
// handle error
}
if (publisher->get_default_datareader_qos(reader_qos) 
    != DDS_RETCODE_OK)
{
    // handle error
}
// copy relevant QoS from topic into reader’s qos
publisher->copy_from_topic_qos(reader_qos, topic_qos);
// Optionally, modify policies as desired
reader_qos.deadline.duration.sec = 1;
reader_qos.deadline.duration.nanosec = 0;
// Create the DataReader with the modified QoS
DDSDataReader* reader = publisher->create_datareader(topic,
    reader_qos, reader_listener, DDS_STATUS_MASK_ALL);

The special macro, DDS_DATAREADER_QOS_USE_TOPIC_QOS, can be used to indicate that the DataReader should be created with the QoS that results from modifying the default DataReader QoS with the values specified by the Topic. See Figure: Combining Default Topic and DataWriter QoS (Option 1) and Figure: Combining Default Topic and DataWriter QoS (Option 2) for examples involving DataWriters. The same pattern applies to DataReaders.

For more information on the general use and manipulation of QosPolicies, see Getting, Setting, and Comparing QosPolicies.

© 2018 RTI