RTI Connext Modern C++ API  Version 6.0.0
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
dds::core::policy::Presentation Class Reference

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

#include <dds/core/policy/CorePolicy.hpp>

Public Member Functions

 Presentation ()
 Create an instance with the default value.
 
 Presentation (dds::core::policy::PresentationAccessScopeKind the_access_scope, bool the_coherent_access, bool the_ordered_access)
 Creates an instance with the specified access scope and coherent and ordered access.
 
Presentationaccess_scope (dds::core::policy::PresentationAccessScopeKind the_access_scope)
 Determines the largest scope spanning the entities for which the order and coherency of changes can be preserved.
 
dds::core::policy::PresentationAccessScopeKind access_scope () const
 Getter (see setter with the same name)
 
Presentationcoherent_access (bool enable)
 Controls whether coherent access is supported within the access_scope.
 
bool coherent_access () const
 Getter (see setter with the same name)
 
Presentationordered_access (bool enable)
 Controls whether ordered access is supported within the access_scope.
 
bool ordered_access () const
 Getter (see setter with the same name)
 

Static Public Member Functions

static Presentation GroupAccessScope (bool coherent, bool ordered)
 Creates a Presentation instnace with group access scope.
 
static Presentation InstanceAccessScope (bool coherent, bool ordered)
 Creates a Presentation instance with instance access scope.
 
static Presentation TopicAccessScope (bool coherent, bool ordered)
 Creates a Presentation instance with topic access scope.
 

Detailed Description

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

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

  • specify and receive coherent changes to instances
  • specify the relative order in which changes are presented
Entity:
dds::pub::Publisher, dds::sub::Subscriber
Status:
dds::core::status::StatusMask::offered_incompatible_qos(), dds::core::status::StatusMask::requested_incompatible_qos()
Properties:
RxO = YES
Changeable = UNTIL ENABLE

Usage

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

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

  • ordered_access controls whether RTI Connext will preserve the order of changes.
  • access_scope controls the granularity of the other settings. See below:

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

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

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

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

For dds::core::policy::PresentationAccessScopeKind_def::GROUP the subscribing application must use the APIs dds::sub::CoherentAccess::CoherentAccess(), dds::sub::CoherentAccess::end() and dds::sub::find to access the changes in the proper order.

Compatibility

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

Constructor & Destructor Documentation

dds::core::policy::Presentation::Presentation ( )
inline

Create an instance with the default value.

dds::core::policy::Presentation::Presentation ( dds::core::policy::PresentationAccessScopeKind  the_access_scope,
bool  the_coherent_access,
bool  the_ordered_access 
)
inline

Creates an instance with the specified access scope and coherent and ordered access.

See the corresponding setters.

Member Function Documentation

Presentation& dds::core::policy::Presentation::access_scope ( dds::core::policy::PresentationAccessScopeKind  the_access_scope)
inline

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

[default] dds::core::policy::PresentationAccessScopeKind_def::INSTANCE

dds::core::policy::PresentationAccessScopeKind dds::core::policy::Presentation::access_scope ( ) const
inline

Getter (see setter with the same name)

Presentation& dds::core::policy::Presentation::coherent_access ( bool  enable)
inline

Controls whether coherent access is supported within the access_scope.

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

Note: To use this feature, the DataWriter must be configured for RELIABLE communication (see dds::core::policy::ReliabilityKind::RELIABLE).

[default] false

bool dds::core::policy::Presentation::coherent_access ( ) const
inline

Getter (see setter with the same name)

Presentation& dds::core::policy::Presentation::ordered_access ( bool  enable)
inline

Controls whether ordered access is supported within the access_scope.

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

[default] false

bool dds::core::policy::Presentation::ordered_access ( ) const
inline

Getter (see setter with the same name)

static Presentation dds::core::policy::Presentation::GroupAccessScope ( bool  coherent,
bool  ordered 
)
inlinestatic

Creates a Presentation instnace with group access scope.

static Presentation dds::core::policy::Presentation::InstanceAccessScope ( bool  coherent,
bool  ordered 
)
inlinestatic

Creates a Presentation instance with instance access scope.

static Presentation dds::core::policy::Presentation::TopicAccessScope ( bool  coherent,
bool  ordered 
)
inlinestatic

Creates a Presentation instance with topic access scope.


RTI Connext Modern C++ API Version 6.0.0 Copyright © Sun Mar 3 2019 Real-Time Innovations, Inc