|
RTI Connext C API Version 7.1.0
|
DDS_DataWriter entity and associated elements More...
Data Structures | |
| struct | FooDataWriter |
| <<interface>> <<generic>> User data type specific data writer. More... | |
| struct | DDS_OfferedDeadlineMissedStatus |
| DDS_OFFERED_DEADLINE_MISSED_STATUS More... | |
| struct | DDS_LivelinessLostStatus |
| DDS_LIVELINESS_LOST_STATUS More... | |
| struct | DDS_OfferedIncompatibleQosStatus |
| DDS_OFFERED_INCOMPATIBLE_QOS_STATUS More... | |
| struct | DDS_PublicationMatchedStatus |
| DDS_PUBLICATION_MATCHED_STATUS More... | |
| struct | DDS_ServiceRequestAcceptedStatus |
| DDS_SERVICE_REQUEST_ACCEPTED_STATUS More... | |
| struct | DDS_ReliableWriterCacheEventCount |
| <<extension>> The number of times the number of unacknowledged samples in the cache of a reliable writer hit a certain well-defined threshold. More... | |
| struct | DDS_ReliableWriterCacheChangedStatus |
| <<extension>> A summary of the state of a data writer's cache of unacknowledged samples written. More... | |
| struct | DDS_ReliableReaderActivityChangedStatus |
| <<extension>> Describes the activity (i.e. are acknowledgements forthcoming) of reliable readers matched to a reliable writer. More... | |
| struct | DDS_DataWriterCacheStatus |
| <<extension>> The status of the DataWriter's cache. Provides information on cache related metrics such as the number of samples and instances in the DataWriter queue. More... | |
| struct | DDS_DataWriterProtocolStatus |
| <<extension>> The status of a writer's internal protocol related metrics, like the number of samples pushed, pulled, filtered; and status of wire protocol traffic. More... | |
| struct | DDS_AcknowledgmentInfo |
| Information about an application-level acknowledged sample. More... | |
| struct | DDS_DataWriterQos |
| QoS policies supported by a DDS_DataWriter entity. More... | |
| struct | DDS_DataWriterListener |
| <<interface>> DDS_Listener for writer status. More... | |
Typedefs | |
| typedef struct DDS_DataWriterImpl | DDS_DataWriter |
| <<interface>> Allows an application to set the value of the data to be published under a given DDS_Topic. More... | |
| typedef void(* | DDS_DataWriterListener_OfferedDeadlineMissedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_OfferedDeadlineMissedStatus *status) |
| Prototype of a DDS_DataWriterListener on_offered_deadline_missed function. More... | |
| typedef void(* | DDS_DataWriterListener_LivelinessLostCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_LivelinessLostStatus *status) |
| Prototype of a DDS_DataWriterListener on_liveliness_lost function. More... | |
| typedef void(* | DDS_DataWriterListener_OfferedIncompatibleQosCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_OfferedIncompatibleQosStatus *status) |
| Prototype of a DDS_DataWriterListener on_offered_incompatible_qos function. More... | |
| typedef void(* | DDS_DataWriterListener_PublicationMatchedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_PublicationMatchedStatus *status) |
| Prototype of a DDS_DataWriterListener on_publication_matched function. More... | |
| typedef void(* | DDS_DataWriterListener_ReliableWriterCacheChangedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ReliableWriterCacheChangedStatus *status) |
| <<extension>> A change has occurred in the writer's cache. More... | |
| typedef void(* | DDS_DataWriterListener_ReliableReaderActivityChangedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ReliableReaderActivityChangedStatus *status) |
| <<extension>> A matched reliable reader has become active or become inactive. More... | |
| typedef void(* | DDS_DataWriterListener_SampleRemovedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_Cookie_t *cookie) |
| <<extension>> A sample has been removed from the DataWriter's queue. More... | |
| typedef void(* | DDS_DataWriterListener_InstanceReplacedCallback) (void *listener_data, DDS_DataWriter *writer, const DDS_InstanceHandle_t *handle) |
| <<extension>> An instance previously registered with the writer has been replaced More... | |
| typedef void(* | DDS_DataWriterListener_OnApplicationAcknowledgmentCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_AcknowledgmentInfo *info) |
| <<extension>> An application-level acknowledgment has been received for a sample More... | |
| typedef void(* | DDS_DataWriterListener_ServiceRequestAcceptedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ServiceRequestAcceptedStatus *status) |
| <<extension>> a DDS_ServiceRequest for the DDS_TopicQuery service is dispatched to this DDS_DataWriter. More... | |
DDS_DataWriter entity and associated elements
| #define DDS_OfferedDeadlineMissedStatus_INITIALIZER |
Initializer for new status instances.
New DDS_OfferedDeadlineMissedStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_OfferedDeadlineMissedStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_LivelinessLostStatus_INITIALIZER |
Initializer for new status instances.
New DDS_LivelinessLostStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_LivelinessLostStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_OfferedIncompatibleQosStatus_INITIALIZER |
Initializer for new status instances.
New DDS_OfferedIncompatibleQosStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_OfferedIncompatibleQosStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_PublicationMatchedStatus_INITIALIZER |
Initializer for new status instances.
New DDS_PublicationMatchedStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_PublicationMatchedStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_ServiceRequestAcceptedStatus_INITIALIZER |
Initializer for new status instances.
New DDS_ServiceRequestAcceptedStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_ServiceRequestAcceptedStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_ReliableWriterCacheChangedStatus_INITIALIZER |
Initializer for new status instances.
New DDS_ReliableWriterCacheChangedStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_ReliableWriterCacheChangedStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_ReliableReaderActivityChangedStatus_INITIALIZER |
Initializer for new status instances.
New DDS_ReliableReaderActivityChangedStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_ReliableReaderActivityChangedStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_DataWriterCacheStatus_INITIALIZER |
Initializer for new status instances.
New DDS_DataWriterCacheStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_DataWriterCacheStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_DataWriterProtocolStatus_INITIALIZER |
Initializer for new status instances.
New DDS_DataWriterProtocolStatus instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those fields that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a status structure is to initialize it on the stack at the time of its creation. DDS_DataWriterProtocolStatus_finalize should be called to free the contained fields that use dynamic memory:
| #define DDS_DataWriterQos_INITIALIZER |
Initializer for new QoS instances.
New DDS_DataWriterQos instances stored on the stack should be initialized with this value before they are passed to any function. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This does not allocate memory.
The simplest way to create a new QoS structure is to initialize it on the stack at the time of its creation:
Note that the above assignment is not a substitute for calling DDS_Publisher_get_default_datawriter_qos or DDS_DataWriter_get_qos; one of those should be called subsequently to setting the QoS of a new or existing entity. DDS_DataWriterQos_finalize should be called to free the contained QoS policies that use dynamic memory:
| #define DDS_DataWriterListener_INITIALIZER |
Initializer for new DDS_DataWriterListener.
All the new DDS_DataWriterListener instances allocated in the stack should be initialized to this value.No memory is allocated.
| typedef struct DDS_DataWriterImpl DDS_DataWriter |
<<interface>> Allows an application to set the value of the data to be published under a given DDS_Topic.
A DDS_DataWriter is attached to exactly one DDS_Publisher, that acts as a factory for it.
A DDS_DataWriter is bound to exactly one DDS_Topic and therefore to exactly one data type. The DDS_Topic must exist prior to the DDS_DataWriter's creation.
DDS_DataWriter is an abstract class. It must be specialized for each particular application data-type (see USER_DATA). The additional methods or functions that must be defined in the auto-generated class for a hypothetical application type Foo are specified in the example type DDS_DataWriter.
The following operations may be called even if the DDS_DataWriter is not enabled. Other operations will fail with DDS_RETCODE_NOT_ENABLED if called on a disabled DDS_DataWriter:
Several DDS_DataWriter may operate in different threads. If they share the same DDS_Publisher, the middleware guarantees that its operations are thread-safe.
| typedef void(* DDS_DataWriterListener_OfferedDeadlineMissedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_OfferedDeadlineMissedStatus *status) |
Prototype of a DDS_DataWriterListener on_offered_deadline_missed function.
| typedef void(* DDS_DataWriterListener_LivelinessLostCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_LivelinessLostStatus *status) |
Prototype of a DDS_DataWriterListener on_liveliness_lost function.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| status | <<out>> Current liveliness lost status of the locally created DDS_DataWriter |
| typedef void(* DDS_DataWriterListener_OfferedIncompatibleQosCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_OfferedIncompatibleQosStatus *status) |
Prototype of a DDS_DataWriterListener on_offered_incompatible_qos function.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| status | <<out>> Current offered incompatible qos status of the locally created DDS_DataWriter |
| typedef void(* DDS_DataWriterListener_PublicationMatchedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_PublicationMatchedStatus *status) |
Prototype of a DDS_DataWriterListener on_publication_matched function.
| typedef void(* DDS_DataWriterListener_ReliableWriterCacheChangedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ReliableWriterCacheChangedStatus *status) |
<<extension>> A change has occurred in the writer's cache.
This callback is triggered when the cache becomes empty or full, or when the number of unacknowledged samples reaches a high or low watermark.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| status | <<out>> Current reliable writer cache changed status of the locally created DDS_DataWriter |
| typedef void(* DDS_DataWriterListener_ReliableReaderActivityChangedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ReliableReaderActivityChangedStatus *status) |
<<extension>> A matched reliable reader has become active or become inactive.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| status | <<out>> Current reliable reader activity changed status of the locally created DDS_DataWriter |
| typedef void(* DDS_DataWriterListener_SampleRemovedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_Cookie_t *cookie) |
<<extension>> A sample has been removed from the DataWriter's queue.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| cookie | <<out>>
|
| typedef void(* DDS_DataWriterListener_InstanceReplacedCallback) (void *listener_data, DDS_DataWriter *writer, const DDS_InstanceHandle_t *handle) |
<<extension>> An instance previously registered with the writer has been replaced
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| handle | <<out>> Handle of the replaced instance |
| typedef void(* DDS_DataWriterListener_OnApplicationAcknowledgmentCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_AcknowledgmentInfo *info) |
<<extension>> An application-level acknowledgment has been received for a sample
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| info | <<out>> DDS_AcknowledgmentInfo of the acknowledged sample |
| typedef void(* DDS_DataWriterListener_ServiceRequestAcceptedCallback) (void *listener_data, DDS_DataWriter *writer, const struct DDS_ServiceRequestAcceptedStatus *status) |
<<extension>> a DDS_ServiceRequest for the DDS_TopicQuery service is dispatched to this DDS_DataWriter.
| listener_data | <<out>> Data associated with the listener when the listener is set |
| writer | <<out>> Locally created DDS_DataWriter that triggers the listener callback |
| status | <<out>> Current service request accepted status of locally created DDS_DataWriter |
| FooDataWriter * FooDataWriter_narrow | ( | DDS_DataWriter * | writer | ) |
Narrow the given DDS_DataWriter pointer to a FooDataWriter pointer.
Check if the given writer is of type FooDataWriter.
| writer | <<in>> Base-class DDS_DataWriter to be converted to the auto-generated class FooDataWriter that extends DDS_DataWriter. Cannot be NULL. |
writer is of type Foo. Return NULL otherwise. | DDS_DataWriter * FooDataWriter_as_datawriter | ( | FooDataWriter * | writer | ) |
Widen the given FooDataWriter pointer to a DDS_DataWriter pointer.
| writer | <<in>> auto-generated FooDataWriter to be converted to the Base-class DDS_DataWriter. Cannot be NULL. |
| DDS_InstanceHandle_t FooDataWriter_register_instance | ( | FooDataWriter * | self, |
| const Foo * | instance_data | ||
| ) |
Informs RTI Connext that the application will be modifying a particular instance.
This operation is only useful for keyed data types. Using it for non-keyed types causes no effect and returns DDS_HANDLE_NIL. The operation takes as a parameter an instance (of which only the key value is examined) and returns a handle that can be used in successive write() or dispose() operations.
The operation gives RTI Connext an opportunity to pre-configure itself to improve performance.
The use of this operation by an application is optional even for keyed types. If an instance has not been pre-registered, the application can use the special value DDS_HANDLE_NIL as the DDS_InstanceHandle_t parameter to the write or dispose operation and RTI Connext will auto-register the instance.
For best performance, the operation should be invoked prior to calling any operation that modifies the instance, such as FooDataWriter_write, FooDataWriter_write_w_timestamp, FooDataWriter_dispose and FooDataWriter_dispose_w_timestamp and the handle used in conjunction with the data for those calls.
When this operation is used, RTI Connext will automatically supply the value of the source_timestamp that is used.
This operation may fail and return DDS_HANDLE_NIL if DDS_ResourceLimitsQosPolicy::max_instances limit has been exceeded.
The operation is idempotent. If it is called for an already registered instance, it just returns the already allocated handle. This may be used to lookup and retrieve the handle allocated to a given instance.
This operation can only be called after DDS_DataWriter has been enabled. Otherwise, DDS_HANDLE_NIL will be returned.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The instance that should be registered. Of this instance, only the fields that represent the key are examined by the function. Cannot be NULL. |
| DDS_InstanceHandle_t FooDataWriter_register_instance_w_timestamp | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const struct DDS_Time_t * | source_timestamp | ||
| ) |
Performs the same functions as register_instance except that the application provides the value for the source_timestamp.
The provided source_timestamp potentially affects the relative order in which readers observe events from multiple writers. Refer to DESTINATION_ORDER QoS policy for details.
This operation may fail and return DDS_HANDLE_NIL if DDS_ResourceLimitsQosPolicy::max_instances limit has been exceeded.
This operation can only be called after DDS_DataWriter has been enabled. Otherwise, DDS_HANDLE_NIL will be returned.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The instance that should be registered. Of this instance, only the fields that represent the key are examined by the function. Cannot be NULL. |
| source_timestamp | <<in>> The timestamp value must be greater than or equal to the timestamp value used in the last writer operation (used in a register, unregister, dispose, or write, with either the automatically supplied timestamp or the application provided timestamp). This timestamp may potentially affect the order in which readers observe events from multiple writers. Cannot be NULL. |
| DDS_InstanceHandle_t FooDataWriter_register_instance_w_params | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| struct DDS_WriteParams_t * | params | ||
| ) |
Performs the same function as FooDataWriter_register_instance and FooDataWriter_register_instance_w_timestamp except that it also provides the values contained in params.
| DDS_ReturnCode_t FooDataWriter_unregister_instance | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | handle | ||
| ) |
Reverses the action of FooDataWriter_register_instance.
This operation is useful only for keyed data types. Using it for non-keyed types causes no effect and reports no error. The operation takes as a parameter an instance (of which only the key value is examined) and a handle.
This operation should only be called on an instance that is currently registered. This includes instances that have been auto-registered by calling operations such as write or dispose as described in FooDataWriter_register_instance. Otherwise, this operation may fail with DDS_RETCODE_BAD_PARAMETER.
This only need be called just once per instance, regardless of how many times register_instance was called for that instance.
When this operation is used, RTI Connext will automatically supply the value of the source_timestamp that is used.
This operation informs RTI Connext that the DDS_DataWriter is no longer going to provide any information about the instance. This operation also indicates that RTI Connext can locally remove all information regarding that instance. The application should not attempt to use the handle previously allocated to that instance after calling this function.
The special value DDS_HANDLE_NIL can be used for the parameter handle. This indicates that the identity of the instance should be automatically deduced from the instance_data (by means of the key).
If handle is any value other than DDS_HANDLE_NIL, then it must correspond to an instance that has been registered. If there is no correspondence, the operation will fail with DDS_RETCODE_BAD_PARAMETER.
RTI Connext will not detect the error when the handle is any value other than DDS_HANDLE_NIL, corresponds to an instance that has been registered, but does not correspond to the instance deduced from the instance_data (by means of the key). RTI Connext will treat as if the unregister_instance() operation is for the instance as indicated by the handle.
If, after a FooDataWriter_unregister_instance, the application wants to modify (FooDataWriter_write or FooDataWriter_dispose) an instance, it has to register it again, or else use the special handle value DDS_HANDLE_NIL.
This operation does not indicate that the instance is deleted (that is the purpose of FooDataWriter_dispose). The operation FooDataWriter_unregister_instance just indicates that the DDS_DataWriter no longer has anything to say about the instance. DDS_DataReader entities that are reading the instance may receive a sample with DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE for the instance, unless there are other DDS_DataWriter objects writing that same instance.
DDS_WriterDataLifecycleQosPolicy::autodispose_unregistered_instances controls whether instances are automatically disposed when they are unregistered.
This operation can affect the ownership of the data instance (see OWNERSHIP). If the DDS_DataWriter was the exclusive owner of the instance, then calling unregister_instance() will relinquish that ownership.
If DDS_ReliabilityQosPolicy::kind is set to DDS_RELIABLE_RELIABILITY_QOS and the unregistration would overflow the resource limits of this writer or of a reader, this operation may block for up to DDS_ReliabilityQosPolicy::max_blocking_time; if this writer is still unable to unregister after that period, this function will fail with DDS_RETCODE_TIMEOUT.
| instance_data | <<in>> The instance that should be unregistered. If Foo has a key and instance_handle is DDS_HANDLE_NIL, only the fields that represent the key are examined by the function. Otherwise, instance_data is not used. If instance_data is used, it must represent an instance that has been registerd. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER . If Foo has a key, instance_data can be NULL only if handle is not DDS_HANDLE_NIL. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. |
| handle | <<in>> represents the instance to be unregistered. If Foo has a key and handle is DDS_HANDLE_NIL, handle is not used and instance is deduced from instance_data. If Foo has no key, handle is not used. If handle is used, it must represent an instance that has been registered. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. If Foo has a key, handle cannot be DDS_HANDLE_NIL if instance_data is NULL. Otherwise, this function will report the error DDS_RETCODE_BAD_PARAMETER. |
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t FooDataWriter_unregister_instance_w_timestamp | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | handle, | ||
| const struct DDS_Time_t * | source_timestamp | ||
| ) |
Performs the same function as FooDataWriter_unregister_instance except that it also provides the value for the source_timestamp.
The provided source_timestamp potentially affects the relative order in which readers observe events from multiple writers. Refer to DESTINATION_ORDER QoS policy for details.
The constraints on the values of the handle parameter and the corresponding error behavior are the same specified for the FooDataWriter_unregister_instance operation.
This operation may block and may time out (DDS_RETCODE_TIMEOUT) under the same circumtances described for the unregister_instance operation.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The instance that should be unregistered. If Foo has a key and instance_handle is DDS_HANDLE_NIL, only the fields that represent the key are examined by the function. Otherwise, instance_data is not used. If instance_data is used, it must represent an instance that has been registerd. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. If Foo has a key, instance_data can be NULL only if handle is not DDS_HANDLE_NIL. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. |
| handle | <<in>> represents the instance to be unregistered. If Foo has a key and handle is DDS_HANDLE_NIL, handle is not used and instance is deduced from instance_data. If Foo has no key, handle is not used. If handle is used, it must represent an instance that has been registered. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. If Foo has a key, handle cannot be DDS_HANDLE_NIL if instance_data is NULL. Otherwise, this function will report the error DDS_RETCODE_BAD_PARAMETER. |
| source_timestamp | <<in>> The timestamp value must be greater than or equal to the timestamp value used in the last writer operation (used in a register, unregister, dispose, or write, with either the automatically supplied timestamp or the application provided timestamp). This timestamp may potentially affect the order in which readers observe events from multiple writers. Cannot be NULL. |
| DDS_ReturnCode_t FooDataWriter_unregister_instance_w_params | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| struct DDS_WriteParams_t * | params | ||
| ) |
Performs the same function as FooDataWriter_unregister_instance and FooDataWriter_unregister_instance_w_timestamp except that it also provides the values contained in params.
| DDS_ReturnCode_t FooDataWriter_write | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | handle | ||
| ) |
Modifies the value of a data instance.
When this operation is used, RTI Connext will automatically supply the value of the source_timestamp that is made available to DDS_DataReader objects by means of the source_timestamp attribute inside the DDS_SampleInfo. (Refer to DDS_SampleInfo and DESTINATION_ORDER QoS policy for details).
As a side effect, this operation asserts liveliness on the DDS_DataWriter itself, the DDS_Publisher and the DDS_DomainParticipant.
Note that the special value DDS_HANDLE_NIL can be used for the parameter handle. This indicates the identity of the instance should be automatically deduced from the instance_data (by means of the key).
If handle is any value other than DDS_HANDLE_NIL, then it must correspond to an instance that has been registered. If there is no correspondence, the operation will fail with DDS_RETCODE_BAD_PARAMETER.
RTI Connext will not detect the error when the handle is any value other than DDS_HANDLE_NIL, corresponds to an instance that has been registered, but does not correspond to the instance deduced from the instance_data (by means of the key). RTI Connext will treat as if the write() operation is for the instance as indicated by the handle.
This operation may block if the RELIABILITY kind is set to DDS_RELIABLE_RELIABILITY_QOS and the modification would cause data to be lost or else cause one of the limits specified in the RESOURCE_LIMITS to be exceeded.
This operation may also block when using DDS_BEST_EFFORT_RELIABILITY_QOS and DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS. In this case, the DDS_DataWriter will queue DDS samples until they are sent by the asynchronous publishing thread. The number of DDS samples that can be stored is determined by the DDS_HistoryQosPolicy. If the asynchronous thread does not send DDS samples fast enough (such as when using a slow DDS_FlowController, the queue may fill up. In that case, subsequent write calls will block.
If DDS_ReliabilityQosPolicy::max_blocking_time elapses before the DDS_DataWriter can store the modification without exceeding the limits, the operation will fail and return DDS_RETCODE_TIMEOUT for KEEP_ALL configurations.
Here is how the write operation behaves when DDS_KEEP_LAST_HISTORY_QOS and DDS_RELIABLE_RELIABILITY_QOS are used:
depth (in the HISTORY) samples in the instance, the DataWriter will replace the oldest sample of that instance independently of that sample's acknowledged status, and the write operation will return DDS_RETCODE_OK. Otherwise, no sample will be replaced and the write operation will continue. If the instance associated with the sample is not present in the writer history and DDS_ResourceLimitsQosPolicy::max_instances is exceeded, the DataWriter will try to replace an existing instance (and its samples) according to the value of DDS_DataWriterResourceLimitsQosPolicy::instance_replacement (see DDS_DataWriterResourceLimitsInstanceReplacementKind).
If DDS_ResourceLimitsQosPolicy::max_samples is exceeded, the DataWriter will try to drop a sample from a different instance as follows:
The sample is added to the writer history, and the write operation returns DDS_RETCODE_OK.
Here is how the write operation behaves when DDS_KEEP_ALL_HISTORY_QOS and DDS_RELIABLE_RELIABILITY_QOS are used:
If there are no instance resources left, this operation may fail with DDS_RETCODE_OUT_OF_RESOURCES. Calling FooDataWriter_unregister_instance may help freeing up some resources.
This operation will fail with DDS_RETCODE_PRECONDITION_NOT_MET if the timestamp is less than the timestamp used in the last writer operation (register, unregister, dispose, or write, with either the automatically supplied timestamp or the application-provided timestamp).
If an instance obtained from FooDataWriter_get_loan is modified with this operation, then all instances modified thereafter should be from FooDataWriter_get_loan.
See DDS_ReliabilityQosPolicyAcknowledgmentModeKind for more information on the following notes:
(1) A sample in the writer history is considered "protocol ACKed" when the sample has been individually ACKed at the RTPS protocol level by each one of the DataReaders that matched the DataWriter at the moment the sample was added to the writer queue.
(2) A sample in the writer history is considered "fully ACKed" when all of the following conditions are met:
(3) It is possible within a single call to the write operation for a DataWriter to block both when the send window is full and then again when DDS_ResourceLimitsQosPolicy::max_samples or DDS_ResourceLimitsQosPolicy::max_samples_per_instance is exceeded. This can happen because blocking on the send window only considers protocol-ACKed samples, while blocking based on resource limits considers fully-ACKed samples. In any case, the total max blocking time of a single call to the write operation will not exceed DDS_ReliabilityQosPolicy::max_blocking_time.
This function will fail with DDS_RETCODE_BAD_PARAMETER if instance_data is NULL.
| handle | <<in>> Either the handle returned by a previous call to FooDataWriter_register_instance, or else the special value DDS_HANDLE_NIL. If Foo has a key and handle is not DDS_HANDLE_NIL, handle must represent a registered instance of type Foo. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. |
instance_data before the operation has finished. The operation is otherwise SAFE. | DDS_ReturnCode_t FooDataWriter_write_w_timestamp | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | handle, | ||
| const struct DDS_Time_t * | source_timestamp | ||
| ) |
Performs the same function as FooDataWriter_write except that it also provides the value for the source_timestamp.
Explicitly provides the timestamp that will be available to the DDS_DataReader objects by means of the source_timestamp attribute inside the DDS_SampleInfo. (Refer to DDS_SampleInfo and DESTINATION_ORDER QoS policy for details)
The constraints on the values of the handle parameter and the corresponding error behavior are the same specified for the FooDataWriter_write operation.
This operation may block and time out (DDS_RETCODE_TIMEOUT) under the same circumtances described for FooDataWriter_write.
If there are no instance resources left, this operation may fail with DDS_RETCODE_OUT_OF_RESOURCES. Calling FooDataWriter_unregister_instance may help free up some resources.
This operation may fail with DDS_RETCODE_BAD_PARAMETER under the same circumstances described for the write operation.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The data to write. This function will fail with DDS_RETCODE_BAD_PARAMETER if instance_data is NULL. |
| handle | <<in>> Either the handle returned by a previous call to FooDataWriter_register_instance, or else the special value DDS_HANDLE_NIL. If Foo has a key and handle is not DDS_HANDLE_NIL, handle must represent a registered instance of type Foo. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. |
| source_timestamp | <<in>> When using DDS_BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS the timestamp value must be greater than or equal to the timestamp value used in the last writer operation (register, unregister, dispose, or write, with either the automatically supplied timestamp or the application-provided timestamp) However, if it is less than the timestamp of the previous operation but the difference is less than the DDS_DestinationOrderQosPolicy::source_timestamp_tolerance, the timestamp of the previous operation will be used as the source timestamp of this sample. Otherwise, if the difference is greater than DDS_DestinationOrderQosPolicy::source_timestamp_tolerance, the function will return DDS_RETCODE_BAD_PARAMETER. |
Cannot be NULL.
| DDS_ReturnCode_t FooDataWriter_write_w_params | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| struct DDS_WriteParams_t * | params | ||
| ) |
Performs the same function as FooDataWriter_write and FooDataWriter_write_w_timestamp except that it also provides the values contained in params.
Allows provision of the sample identity, related sample identity, source timestamp, instance handle, and publication priority contained in params.
This operation may block and time out (DDS_RETCODE_TIMEOUT) under the same circumstances described for FooDataWriter_write.
If there are no instance resources left, this operation may fail with DDS_RETCODE_OUT_OF_RESOURCES. Calling FooDataWriter_unregister_instance_w_params may help free up some resources.
This operation may fail with DDS_RETCODE_BAD_PARAMETER under the same circumstances described for the FooDataWriter_write.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The data to write. This function will fail with DDS_RETCODE_BAD_PARAMETER if instance_data is NULL. |
| params | <<inout>> The write parameters. Note that this is an inout parameter if you activate DDS_WriteParams_t::replace_auto; otherwise it won't be modified. This function will fail with DDS_RETCODE_BAD_PARAMETER if params is NULL. |
| DDS_ReturnCode_t FooDataWriter_dispose | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | instance_handle | ||
| ) |
Requests the middleware to delete the instance.
This operation is useful only for keyed data types. Using it for non-keyed types has no effect and reports no error.
When an instance is disposed, the DDS_DataWriter communicates this state change to DDS_DataReader objects by propagating a dispose sample. When the instance changes to a disposed state, you can see the state change on the DataReader by looking at DDS_SampleInfo::instance_state. Disposed instances have the value DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE.
The resources allocated to dispose instances on the DataWriter are not removed by default. The removal of the resources allocated to a dispose instance on the DataWriter queue can be controlled by using the QoS DDS_WriterDataLifecycleQosPolicy::autopurge_disposed_instances_delay.
Likewise, on the DataReader, the removal of the resources associated with an instance in the dispose state can be controlled by using the QoS DDS_ReaderDataLifecycleQosPolicy::autopurge_disposed_instances_delay.
This operation does not modify the value of the instance. The instance_data parameter is passed just for the purposes of identifying the instance.
When this operation is used, RTI Connext will automatically supply the value of the source_timestamp that is made available to DDS_DataReader objects by means of the source_timestamp attribute inside the DDS_SampleInfo.
The constraints on the values of the handle parameter and the corresponding error behavior are the same specified for the FooDataWriter_unregister_instance operation.
The special value DDS_HANDLE_NIL can be used for the parameter instance_handle. This indicates the identity of the instance should be automatically deduced from the instance_data (by means of the key).
If instance_handle is any value other than DDS_HANDLE_NIL, then it must correspond to an instance that has been registered. If there is no correspondence, the operation will fail with DDS_RETCODE_BAD_PARAMETER.
RTI Connext will not detect the error when the instance_handle is any value other than DDS_HANDLE_NIL, and the instance_handle corresponds to an instance that has been registered but does not correspond to the instance deduced from the instance_data (by means of the key). In this case, the instance that will be disposed is the instance corresponding to the instance_handle, not to the instance_data.
This operation may block and time out (DDS_RETCODE_TIMEOUT) under the same circumstances described for FooDataWriter_write.
If there are no instance resources left, this operation may fail with DDS_RETCODE_OUT_OF_RESOURCES. Calling FooDataWriter_unregister_instance may help free up some resources.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The data to dispose. If Foo has a key and instance_handle is DDS_HANDLE_NIL, only the fields that represent the key are examined by the function. Otherwise, instance_data is not used. If Foo has a key, instance_data can be NULL only if instance_handle is not DDS_HANDLE_NIL. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. |
| instance_handle | <<in>> Either the handle returned by a previous call to FooDataWriter_register_instance, or else the special value DDS_HANDLE_NIL. If Foo has a key and instance_handle is DDS_HANDLE_NIL, instance_handle is not used and it is deduced from instance_data. If Foo has no key, instance_handle is not used. If instance_handle is used, it must represent an instance of type Foo that has been written or registered with this writer. Otherwise, this function fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if instance_handle is NULL. If Foo has a key, instance_handle cannot be DDS_HANDLE_NIL if instance_data is NULL. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. |
| DDS_ReturnCode_t FooDataWriter_dispose_w_timestamp | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| const DDS_InstanceHandle_t * | instance_handle, | ||
| const struct DDS_Time_t * | source_timestamp | ||
| ) |
Performs the same functions as dispose except that the application provides the value for the source_timestamp that is made available to DDS_DataReader objects by means of the source_timestamp attribute inside the DDS_SampleInfo.
The constraints on the values of the handle parameter and the corresponding error behavior are the same specified for the FooDataWriter_dispose operation.
This operation may block and time out (DDS_RETCODE_TIMEOUT) under the same circumtances described for FooDataWriter_write.
If there are no instance resources left, this operation may fail with DDS_RETCODE_OUT_OF_RESOURCES. Calling FooDataWriter_unregister_instance may help freeing up some resources.
| self | <<in>> Cannot be NULL. |
| instance_data | <<in>> The data to dispose. If Foo has a key and instance_handle is DDS_HANDLE_NIL, only the fields that represent the key are examined by the function. Otherwise, instance_data is not used. If Foo has a key, instance_data can be NULL only if instance_handle is not DDS_HANDLE_NIL. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. |
| instance_handle | <<in>> Either the handle returned by a previous call to FooDataWriter_register_instance, or else the special value DDS_HANDLE_NIL. If Foo has a key and handle is not DDS_HANDLE_NIL, handle must represent a registered instance of type Foo. Otherwise, this function may fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. |
| source_timestamp | <<in>> The timestamp value must be greater than or equal to the timestamp value used in the last writer operation (used in a register, unregister, dispose, or write, with either the automatically supplied timestamp or the application provided timestamp). This timestamp may potentially affect the order in which readers observe events from multiple writers. This timestamp will be available to the DDS_DataReader objects by means of the source_timestamp attribute inside the DDS_SampleInfo. Cannot be NULL. |
| DDS_ReturnCode_t FooDataWriter_dispose_w_params | ( | FooDataWriter * | self, |
| const Foo * | instance_data, | ||
| struct DDS_WriteParams_t * | params | ||
| ) |
Performs the same function as FooDataWriter_dispose and FooDataWriter_dispose_w_timestamp except that it also provides the values contained in params.
| DDS_ReturnCode_t FooDataWriter_get_key_value | ( | FooDataWriter * | self, |
| Foo * | key_holder, | ||
| const DDS_InstanceHandle_t * | handle | ||
| ) |
Retrieve the instance key that corresponds to an instance handle.
Useful for keyed data types.
The operation will only fill the fields that form the key inside the key_holder instance. If the type has no keys, this function has no effect and exits with no error.
For keyed data types, this operation may fail with DDS_RETCODE_BAD_PARAMETER if the handle does not correspond to an existing data-object known to the DDS_DataWriter.
| self | <<in>> Cannot be NULL. |
| key_holder | <<inout>> a user data type specific key holder, whose key fields are filled by this operation. If Foo has no key, this function has no effect. |
This function will fail with DDS_RETCODE_BAD_PARAMETER if key_holder is NULL.
| handle | <<in>> the instance whose key is to be retrieved. If Foo has a key, handle must represent a registered instance of type Foo. Otherwise, this function will fail with DDS_RETCODE_BAD_PARAMETER. If Foo has a key and handle is DDS_HANDLE_NIL, this function will fail with DDS_RETCODE_BAD_PARAMETER. This function will fail with DDS_RETCODE_BAD_PARAMETER if handle is NULL. |
| DDS_InstanceHandle_t FooDataWriter_lookup_instance | ( | FooDataWriter * | self, |
| const Foo * | key_holder | ||
| ) |
Retrieve the instance handle that corresponds to an instance key_holder.
Useful for keyed data types.
This operation takes as a parameter an instance and returns a handle that can be used in subsequent operations that accept an instance handle as an argument. The instance parameter is only used for the purpose of examining the fields that define the key. This operation does not register the instance in question. If the instance has not been previously registered, or if for any other reason RTI Connext is unable to provide an instance handle, RTI Connext will return the special value HANDLE_NIL.
| void * FooDataWriter_create_data | ( | FooDataWriter * | self | ) |
Creates a data sample and initializes it.
The behavior of this API is identical to FooTypeSupport_create_data.
| self | <<in>> Cannot be NULL. |
| void * FooDataWriter_create_data_w_params | ( | FooDataWriter * | self, |
| const struct DDS_TypeAllocationParams_t * | alloc_params | ||
| ) |
Creates a data sample and initializes it.
The behavior of this API is identical to FooTypeSupport_create_data_w_params.
| self | <<in>> Cannot be NULL. |
| alloc_params | <<in>> Whether or not to recursively allocate pointers and/or optional members |
| DDS_Boolean FooDataWriter_delete_data | ( | FooDataWriter * | self, |
| Foo * | sample | ||
| ) |
Destroys a user data type instance.
The behavior of this API is identical to FooTypeSupport_delete_data.
| void * FooDataWriter_delete_data_w_params | ( | FooDataWriter * | self, |
| Foo * | sample, | ||
| const struct DDS_TypeDeallocationParams_t * | dealloc_params | ||
| ) |
Destroys a user data type instance.
The behavior of this API is identical to FooTypeSupport_delete_data_w_params.
| self | <<in>> Cannot be NULL. |
| sample | <<in>> Cannot be NULL. |
| dealloc_params | <<in>> Whether or not to destroy pointers and/or optional members. |
| DDS_ReturnCode_t FooDataWriter_get_loan | ( | FooDataWriter * | self, |
| Foo ** | sample | ||
| ) |
Gets a sample managed by the DataWriter.
This operation is supported while using Zero Copy transfer over shared memory" or \ref RTIFlatDataModule "FlatData language binding".
The loaned sample is obtained from a DataWriter-managed sample pool and is uninitialized by default. An initialized sample can be obtained by setting DDS_DataWriterResourceLimitsQosPolicy::initialize_writer_loaned_sample to DDS_BOOLEAN_TRUE. The DDS_DataWriterResourceLimitsQosPolicy::writer_loaned_sample_allocation settings can be used to configure the DataWriter-managed sample pool.
FooDataWriter_get_loan fails with DDS_RETCODE_OUT_OF_RESOURCES if DDS_AllocationSettings_t::max_count samples have been loaned, and none of those samples has been written with FooDataWriter_write or discarded via FooDataWriter_discard_loan.
Samples returned from FooDataWriter_get_loan have an associated state. Due to the optimized nature of the write operation while using Zero Copy transfer over shared memory or FlatData language binding, this sample state is used to control when a sample is available for reuse after the write operation. The possible sample states are free, allocated, removed or serialized. A sample that has never been allocated is "free". FooDataWriter_get_loan takes a "free" or "removed" sample and makes it "allocated". When a sample is written, its state transitions from "allocated" to "serialized", and the DataWriter takes responsibility for returning the sample back to its sample pool. The sample remains in the "serialized" state until it is removed from the DataWriter queue. For a reliable DataWriter, the sample is removed from the DataWriter's queue when the sample is acknowledged by all DataReaders. For a best-effort DataWriter, the sample is removed from the queue immediately after the write operation. After the sample is removed from the DataWriter queue, the sample is put back into the sample pool, and its state transitions from "serialized" to "removed". At this time, a new call to FooDataWriter_get_loan may return the same sample.
A loaned sample should not be reused to write a new value after the first write operation. Instead, a new sample from FooDataWriter_get_loan should be used to write the new value. A loaned sample that has not been written can be returned to the DataWriter's sample pool by using FooDataWriter_discard_loan. If the write operation fails, then the sample can be used again with a write or discard_loan operation. Disposing or unregistering an instance with loaned samples follows the same pattern. A loaned sample used successfully with a dispose or unregister operation cannot be used again. But if the dispose or unregister operation fails, the sample is available for reuse.
A DataWriter cannot write managed samples (created with get_loan) and unmanaged samples (created in any other way) at the same time. The first call to get_loan automatically prepares this DataWriter to work with managed samples. Calls to get_loan will fail with DDS_RETCODE_PRECONDITION_NOT_MET if an unmanaged sample was written with this DataWriter earlier. Similarly, FooDataWriter_write will fail to write an unmanaged sample if get_loan was called.
| self | <<in>> Cannot be NULL. |
| sample | <<inout>> address of a user data type pointer. The loaned sample is returned via this sample. |
| DDS_ReturnCode_t FooDataWriter_discard_loan | ( | FooDataWriter * | self, |
| Foo * | sample | ||
| ) |
Returns a loaned sample back to the DataWriter.
This operation is supported while using Zero Copy transfer over shared memory" or the FlatData language binding.
A loaned sample that hasn't been written can be returned to the DataWriter with this operation.
| DDS_ReturnCode_t DDS_OfferedDeadlineMissedStatus_initialize | ( | struct DDS_OfferedDeadlineMissedStatus * | self | ) |
Initializer for new status instances.
New DDS_OfferedDeadlineMissedStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_OfferedDeadlineMissedStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_OfferedDeadlineMissedStatus_copy | ( | struct DDS_OfferedDeadlineMissedStatus * | self, |
| const struct DDS_OfferedDeadlineMissedStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_OfferedDeadlineMissedStatus_finalize | ( | struct DDS_OfferedDeadlineMissedStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_LivelinessLostStatus_initialize | ( | struct DDS_LivelinessLostStatus * | self | ) |
Initializer for new status instances.
New DDS_LivelinessLostStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_LivelinessLostStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_LivelinessLostStatus_copy | ( | struct DDS_LivelinessLostStatus * | self, |
| const struct DDS_LivelinessLostStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_LivelinessLostStatus_finalize | ( | struct DDS_LivelinessLostStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_OfferedIncompatibleQosStatus_initialize | ( | struct DDS_OfferedIncompatibleQosStatus * | self | ) |
Initializer for new status instances.
New DDS_OfferedIncompatibleQosStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_OfferedIncompatibleQosStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_OfferedIncompatibleQosStatus_copy | ( | struct DDS_OfferedIncompatibleQosStatus * | self, |
| const struct DDS_OfferedIncompatibleQosStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_OfferedIncompatibleQosStatus_finalize | ( | struct DDS_OfferedIncompatibleQosStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_PublicationMatchedStatus_initialize | ( | struct DDS_PublicationMatchedStatus * | self | ) |
Initializer for new status instances.
New DDS_PublicationMatchedStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_PublicationMatchedStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_PublicationMatchedStatus_copy | ( | struct DDS_PublicationMatchedStatus * | self, |
| const struct DDS_PublicationMatchedStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_PublicationMatchedStatus_finalize | ( | struct DDS_PublicationMatchedStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_ServiceRequestAcceptedStatus_initialize | ( | struct DDS_ServiceRequestAcceptedStatus * | self | ) |
Initializer for new status instances.
New DDS_ServiceRequestAcceptedStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_ServiceRequestAcceptedStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_ServiceRequestAcceptedStatus_copy | ( | struct DDS_ServiceRequestAcceptedStatus * | self, |
| const struct DDS_ServiceRequestAcceptedStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_ServiceRequestAcceptedStatus_finalize | ( | struct DDS_ServiceRequestAcceptedStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_ReliableWriterCacheChangedStatus_initialize | ( | struct DDS_ReliableWriterCacheChangedStatus * | self | ) |
Initializer for new status instances.
New DDS_ReliableWriterCacheChangedStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_ReliableWriterCacheChangedStatus_finalize should be called to free the contained fields that use dynamic memory:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_ReliableWriterCacheChangedStatus_copy | ( | struct DDS_ReliableWriterCacheChangedStatus * | self, |
| const struct DDS_ReliableWriterCacheChangedStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_ReliableWriterCacheChangedStatus_finalize | ( | struct DDS_ReliableWriterCacheChangedStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_ReliableReaderActivityChangedStatus_initialize | ( | struct DDS_ReliableReaderActivityChangedStatus * | self | ) |
Initializer for new status instances.
New DDS_ReliableReaderActivityChangedStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_ReliableReaderActivityChangedStatus_finalize should be called to free the contained fields that use dynamic memory:
| DDS_ReturnCode_t DDS_ReliableReaderActivityChangedStatus_copy | ( | struct DDS_ReliableReaderActivityChangedStatus * | self, |
| const struct DDS_ReliableReaderActivityChangedStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_ReliableReaderActivityChangedStatus_finalize | ( | struct DDS_ReliableReaderActivityChangedStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriterCacheStatus_initialize | ( | struct DDS_DataWriterCacheStatus * | self | ) |
Initializer for new status instances.
New DDS_DataWriterCacheStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_DataWriterCacheStatus_finalize should be called to free the contained fields that use dynamic memory:
| DDS_ReturnCode_t DDS_DataWriterCacheStatus_copy | ( | struct DDS_DataWriterCacheStatus * | self, |
| const struct DDS_DataWriterCacheStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_DataWriterCacheStatus_finalize | ( | struct DDS_DataWriterCacheStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriterProtocolStatus_initialize | ( | struct DDS_DataWriterProtocolStatus * | self | ) |
Initializer for new status instances.
New DDS_DataWriterProtocolStatus instance on heap should be initialized with this function before they are passed to any function. This step ensures that those contained fields that use dynamic memory are properly initialized. This function does not allocate memory.
DDS_DataWriterProtocolStatus_finalize should be called to free the contained fields that use dynamic memory:
| DDS_ReturnCode_t DDS_DataWriterProtocolStatus_copy | ( | struct DDS_DataWriterProtocolStatus * | self, |
| const struct DDS_DataWriterProtocolStatus * | source | ||
| ) |
Copy the contents of the given status into this status.
Status instances can use dynamic memory because of the sequences contained in some status. A shallow copy by assignment is therefore unsafe. This function performs a deep-copy, allocating memory if necessary.
| DDS_ReturnCode_t DDS_DataWriterProtocolStatus_finalize | ( | struct DDS_DataWriterProtocolStatus * | self | ) |
Free any dynamic memory allocated by status instances.
some status may use dynamic memory (regardless of whether the status itself is in dynamic memory). This function frees that memory but otherwise leaves this status 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).
Note that if this status instance is stored in heap memory, calling this function will not call free() on it; the user is responsible for explicitly freeing any heap-based status instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_Boolean DDS_DataWriterQos_equals | ( | const struct DDS_DataWriterQos * | self, |
| const struct DDS_DataWriterQos * | other | ||
| ) |
Compares two DDS_DataWriterQos for equality.
| self | <<in>> This DataWriterQos. |
| other | <<in>> The other DataWriterQos to be compared with this DataWriterQos. |
| DDS_ReturnCode_t DDS_DataWriterQos_print | ( | const struct DDS_DataWriterQos * | self | ) |
Prints this DDS_DataWriterQos to stdout.
Only the differences between this DDS_DataWriterQos and the documented default are printed. If you wish to print everything regardless, see DDS_DataWriterQos_to_string_w_params. The output is formatted according to the default values for DDS_QosPrintFormat.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriterQos_to_string | ( | const struct DDS_DataWriterQos * | self, |
| char * | string, | ||
| DDS_UnsignedLong * | string_size | ||
| ) |
Obtains a string representation of this DDS_DataWriterQos.
Only the differences between this DDS_DataWriterQos and the documented default are printed to the string. If you wish to print everything regardless, see DDS_DataWriterQos_to_string_w_params. The output is formatted according to the default values for DDS_QosPrintFormat.
If the supplied buffer is NULL, the required length of the string is returned via the string_size parameter.
If the supplied buffer is not NULL, the string representation of the DDS_DataWriterQos is written to the buffer.
| self | <<in>> Cannot be NULL. |
| string | <<out>> The char buffer that will be used to store the string representation of this DDS_DataWriterQos. If NULL, this function will return the required length of this buffer through the string_size parameter. |
| string_size | <<inout>> Cannot be NULL. The size of the supplied buffer. If the supplied buffer is NULL, or if the supplied buffer is not large enough, this value will be updated with the required length of the buffer. |
| DDS_ReturnCode_t DDS_DataWriterQos_to_string_w_params | ( | const struct DDS_DataWriterQos * | self, |
| char * | string, | ||
| DDS_UnsignedLong * | string_size, | ||
| const struct DDS_DataWriterQos * | base, | ||
| const struct DDS_QosPrintFormat * | format | ||
| ) |
Obtains a string representation of this DDS_DataWriterQos.
Only the differences between this DDS_DataWriterQos and the DDS_DataWriterQos supplied as the base are printed to the string.
It is possible to supply the sentinel value DDS_DATAWRITER_QOS_PRINT_ALL as the base to print everything within the QoS.
If the supplied buffer is NULL, the required length of the string is returned via the string_size parameter.
If the supplied buffer is not NULL, the string representation of the DDS_DataWriterQos is written to the buffer.
| self | <<in>> Cannot be NULL. |
| string | <<out>> The char buffer that will be used to store the string representation of this DDS_DataWriterQos. If NULL, this function will return the required length of this buffer through the string_size parameter. |
| string_size | <<inout>> Cannot be NULL. The size of the supplied buffer. If the supplied buffer is NULL, or if the supplied buffer is not large enough, this value will be updated with the required length of the buffer. |
| base | <<in>> The DDS_DataWriterQos to be used as the base QoS profile. Only the differences with respect to this base profile will be included in the output string. |
| format | <<in>> The DDS_QosPrintFormat to be used to format the output string. |
| DDS_ReturnCode_t DDS_DataWriterQos_initialize | ( | struct DDS_DataWriterQos * | self | ) |
Initializer for new QoS instances.
New DDS_DataWriterQos instances on heap should be initialized with this function before they are passed to any function. This step ensures that those contained QoS policies that use dynamic memory are properly initialized. This function does not allocate memory.
Calling this function 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:
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriterQos_finalize | ( | struct DDS_DataWriterQos * | self | ) |
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 function 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 function 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 function will not call free() on it; the user is responsible for explicitly freeing any heap-based QoS instance after calling this function.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriterQos_copy | ( | struct DDS_DataWriterQos * | self, |
| const struct DDS_DataWriterQos * | source | ||
| ) |
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 function performs a deep-copy, allocating memory if necessary.
| self | <<in>> Cannot be NULL. |
| source | <<in>> The DDS_DataWriterQos to copy from. |
| DDS_Entity * DDS_DataWriter_as_entity | ( | DDS_DataWriter * | dataWriter | ) |
Access a DDS_DataWriter's supertype instance.
| dataWriter | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_assert_liveliness | ( | DDS_DataWriter * | self | ) |
This operation manually asserts the liveliness of this DDS_DataWriter.
This is used in combination with the LIVELINESS policy to indicate to RTI Connext that the DDS_DataWriter remains active.
You only need to use this operation if the LIVELINESS setting is either DDS_MANUAL_BY_PARTICIPANT_LIVELINESS_QOS or DDS_MANUAL_BY_TOPIC_LIVELINESS_QOS. Otherwise, it has no effect.
Note: writing data via the FooDataWriter_write or FooDataWriter_write_w_timestamp operation asserts liveliness on the DDS_DataWriter itself, and its DDS_DomainParticipant. Consequently the use of assert_liveliness() is only needed if the application is not writing data regularly.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_locators | ( | DDS_DataWriter * | self, |
| struct DDS_LocatorSeq * | locators | ||
| ) |
<<extension>> Retrieve the list of locators for subscriptions currently "associated" with this DDS_DataWriter.
The locators returned in the locators list are the ones that are used by the DDS implementation to communicate with the corresponding matched DDS_DataReader entities.
| self | <<in>> Cannot be NULL. |
| locators | <<inout>>. Handles of all the matched subscription locators. |
The sequence will be grown if the sequence has ownership and the system has the corresponding resources. Use a sequence without ownership to avoid dynamic memory allocation. If the sequence is too small to store all the matches and the system can not resize the sequence, this function will fail with DDS_RETCODE_OUT_OF_RESOURCES. Cannot be NULL. .
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscriptions | ( | DDS_DataWriter * | self, |
| struct DDS_InstanceHandleSeq * | subscription_handles | ||
| ) |
Retrieve the list of subscriptions currently "associated" with this DDS_DataWriter.
A subscription is considered to be matching if all of the following criteria are true:
The handles returned in the subscription_handles list are the ones that RTI Connext uses to locally identify the corresponding matched DDS_DataReader entities. These handles match the ones that appear in the DDS_SampleInfo::instance_handle field of the DDS_SampleInfo when reading the DDS_SUBSCRIPTION_TOPIC_NAME builtin topic.
This API may return the subscription handles of subscriptions that are inactive. DDS_DataWriter_is_matched_subscription_active can be used to check this.
| self | <<in>> Cannot be NULL. |
| subscription_handles | <<inout>>. The handles of all the matched subscriptions. |
The sequence will be grown if the sequence has ownership and the system has the corresponding resources. Use a sequence without ownership to avoid dynamic memory allocation. If the sequence is too small to store all of the matches and the system cannot resize the sequence, this function will fail with DDS_RETCODE_OUT_OF_RESOURCES.
The maximum number of matches possible is configured with DDS_DomainParticipantResourceLimitsQosPolicy. You can use a zero-maximum sequence without ownership to quickly check whether there are any matches without allocating any memory. Cannot be NULL. .
| DDS_ReturnCode_t DDS_DataWriter_is_matched_subscription_active | ( | DDS_DataWriter * | self, |
| DDS_Boolean * | is_active, | ||
| const DDS_InstanceHandle_t * | subscription_handle | ||
| ) |
Check if a subscription currently matched with a DataWriter is active.
This API is used for querying the endpoint liveliness of a matched subscription. A matched subscription will be marked as inactive when it becomes nonprogessing (e.g., not responding to a DataWriter's heartbeats, or letting its internal queue fill up without taking the available data). Note that if the participant associated with the matched subscription loses liveliness, the DDS_InstanceHandle_t will become invalid and this function will fail with DDS_RETCODE_BAD_PARAMETER.
| self | <<in>> Cannot be NULL. |
| subscription_handle | <<in>> The DDS_InstanceHandle_t of the matched subscription. See DDS_DataWriter_get_matched_subscriptions for a description of what is considered a matched subscription. |
| is_active | <<out>> Indicates whether or not the matched subscription is active. |
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_data | ( | DDS_DataWriter * | self, |
| struct DDS_SubscriptionBuiltinTopicData * | subscription_data, | ||
| const DDS_InstanceHandle_t * | subscription_handle | ||
| ) |
This operation retrieves the information on a subscription that is currently "associated" with the DDS_DataWriter.
The subscription_handle must correspond to a subscription currently associated with the DDS_DataWriter. Otherwise, the operation will fail and fail with DDS_RETCODE_BAD_PARAMETER. Use DDS_DataWriter_get_matched_subscriptions to find the subscriptions that are currently matched with the DDS_DataWriter.
The above information is also available through DDS_DataReaderListener::on_data_available() (if a reader listener is installed on the DDS_SubscriptionBuiltinTopicDataDataReader).
When the subscription data is updated, for example when the content filter property changes, there is a small window of time in between when the DataWriter is made aware of these changes and when they actually take effect. Taking effect in this example means that the DataWriter will perform writer-side filtering using the new filter property values (filter expression and/or parameters).
When the DataWriter is made aware of the changes they will first be seen in the DDS_DataReaderListener::on_data_available() of the DDS_SubscriptionBuiltinTopicDataDataReader. When these changes are applied, they will be seen in the output of this API because this API blocks until the most recent changes known to the DataWriter have taken effect. This API will only block when called outside of a listener callback, in order to not block the internal threads from making progress.
If application behavior depends on being made aware of information about a subscription only after it has taken effect on the DataWriter, the recommended pattern for usage of this API is to wait for subscription data to be received either through polling this API or by installing a listener on the DDS_SubscriptionBuiltinTopicDataDataReader. When a new sample is received by the builtin DataReader, this API may be called in a separate thread and will return the expected matched subscription data once it has been applied to the DataWriter.
Because this API blocks, it is possible for this API to time out while waiting for the changes to be applied. A timeout may happen if the DataReader's subscription data is changing rapidly, preventing the DataWriter from returning valid information before newer data has been received, or if an application is performing a task in a listener callback, thereby preventing the middleware's threads from executing events in a timely manner.
Note: This operation does not retrieve the DDS_SubscriptionBuiltinTopicData::type_code. This information is available through DDS_DataReaderListener::on_data_available() (if a reader listener is installed on the DDS_SubscriptionBuiltinTopicDataDataReader).
| self | <<in>> Cannot be NULL. |
| subscription_data | <<inout>>. The information to be filled in on the associated subscription. Cannot be NULL. |
| subscription_handle | <<in>>. Handle to a specific subscription associated with the DDS_DataReader. Must correspond to a subscription currently associated with the DDS_DataWriter. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_participant_data | ( | DDS_DataWriter * | self, |
| struct DDS_ParticipantBuiltinTopicData * | participant_data, | ||
| const DDS_InstanceHandle_t * | subscription_handle | ||
| ) |
This operation retrieves the information on the discovered DDS_DomainParticipant associated with the subscription that is currently matching with the DDS_DataWriter.
The subscription_handle must correspond to a subscription currently associated with the DDS_DataWriter. Otherwise, the operation will fail with DDS_RETCODE_BAD_PARAMETER. The operation may also fail with DDS_RETCODE_PRECONDITION_NOT_MET if the subscription corresponds to the same DDS_DomainParticipant that the DataWriter belongs to. Use DDS_DataWriter_get_matched_subscriptions to find the subscriptions that are currently matched with the DDS_DataWriter.
| self | <<in>> Cannot be NULL. |
| participant_data | <<inout>>. The information to be filled in on the associated participant Cannot be NULL. |
| subscription_handle | <<in>>. Handle to a specific subscription associated with the DDS_DataReader. Must correspond to a subscription currently associated with the DDS_DataWriter. |
Cannot be NULL.
| DDS_Topic * DDS_DataWriter_get_topic | ( | DDS_DataWriter * | self | ) |
This operation returns the DDS_Topic associated with the DDS_DataWriter.
This is the same DDS_Topic that was used to create the DDS_DataWriter.
| self | <<in>> Cannot be NULL. |
| DDS_Publisher * DDS_DataWriter_get_publisher | ( | DDS_DataWriter * | self | ) |
This operation returns the DDS_Publisher to which the DDS_DataWriter belongs.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_wait_for_acknowledgments | ( | DDS_DataWriter * | self, |
| const struct DDS_Duration_t * | max_wait | ||
| ) |
Blocks the calling thread until all data written by reliable DDS_DataWriter entity is acknowledged, or until timeout expires.
This operation blocks the calling thread until either all data written by the reliable DDS_DataWriter entity is acknowledged by (a) all reliable DDS_DataReader entities that are matched and alive and (b) by all required subscriptions, or until the duration specified by the max_wait parameter elapses, whichever happens first. A successful completion indicates that all the samples written have been acknowledged by all reliable matched data readers and by all required subscriptions; a timeout indicates that max_wait elapsed before all the data was acknowledged.
Note that if a thread is blocked in the call to wait_for_acknowledgments on a DataWriter and a different thread writes new samples on the same DataWriter, the new samples must be acknowledged before unblocking the thread waiting on wait_for_acknowledgments.
If the DDS_DataWriter does not have DDS_ReliabilityQosPolicy kind set to RELIABLE, this operation will complete immediately with DDS_RETCODE_OK
| self | <<in>> Cannot be NULL. |
| max_wait | <<in>> Specifies maximum time to wait for acknowledgements DDS_Duration_t . |
| DDS_ReturnCode_t DDS_DataWriter_is_sample_app_acknowledged | ( | DDS_DataWriter * | self, |
| DDS_Boolean * | is_app_ack, | ||
| const struct DDS_SampleIdentity_t * | identity | ||
| ) |
This function can be used to see if a sample has been application acknowledged.
This function can be used to see if a sample has been application acknowledged by all the matching DataReaders that were alive when the sample was written.
If a DataReader does not enable application acknowledgment (by setting DDS_ReliabilityQosPolicy::acknowledgment_kind to a value other than DDS_PROTOCOL_ACKNOWLEDGMENT_MODE), the sample is considered application acknowledged for that DataReader.
| self | <<in>> Cannot be NULL. |
| is_app_ack | <<out>> This value will be set to DDS_BOOLEAN_TRUE when the sample has been acknowledged. |
| identity | <<in>> Sample identity. |
| DDS_ReturnCode_t DDS_DataWriter_wait_for_asynchronous_publishing | ( | DDS_DataWriter * | self, |
| const struct DDS_Duration_t * | max_wait | ||
| ) |
<<extension>> Blocks the calling thread until asynchronous sending is complete.
This operation blocks the calling thread (up to max_wait) until all data written by the asynchronous DDS_DataWriter is sent and acknowledged (if reliable) by all matched DDS_DataReader entities. A successful completion indicates that all the samples written have been sent and acknowledged where applicable; a time out indicates that max_wait elapsed before all the data was sent and/or acknowledged.
In other words, this guarantees that sending to best effort DDS_DataReader is complete in addition to what DDS_DataWriter_wait_for_acknowledgments provides.
If the DDS_DataWriter does not have DDS_PublishModeQosPolicy kind set to DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS the operation will complete immediately with DDS_RETCODE_OK.
| self | <<in>> Cannot be NULL. |
| max_wait | <<in>> Specifies maximum time to wait for acknowledgements DDS_Duration_t . |
| DDS_ReturnCode_t DDS_DataWriter_get_liveliness_lost_status | ( | DDS_DataWriter * | self, |
| struct DDS_LivelinessLostStatus * | status | ||
| ) |
Accesses the DDS_LIVELINESS_LOST_STATUS communication status.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_LivelinessLostStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_offered_deadline_missed_status | ( | DDS_DataWriter * | self, |
| struct DDS_OfferedDeadlineMissedStatus * | status | ||
| ) |
Accesses the DDS_OFFERED_DEADLINE_MISSED_STATUS communication status.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_OfferedDeadlineMissedStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_offered_incompatible_qos_status | ( | DDS_DataWriter * | self, |
| struct DDS_OfferedIncompatibleQosStatus * | status | ||
| ) |
Accesses the DDS_OFFERED_INCOMPATIBLE_QOS_STATUS communication status.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_OfferedIncompatibleQosStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_publication_matched_status | ( | DDS_DataWriter * | self, |
| struct DDS_PublicationMatchedStatus * | status | ||
| ) |
Accesses the DDS_PUBLICATION_MATCHED_STATUS communication status.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_PublicationMatchedStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_reliable_writer_cache_changed_status | ( | DDS_DataWriter * | self, |
| struct DDS_ReliableWriterCacheChangedStatus * | status | ||
| ) |
<<extension>> Get the reliable cache status for this writer.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_ReliableWriterCacheChangedStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_reliable_reader_activity_changed_status | ( | DDS_DataWriter * | self, |
| struct DDS_ReliableReaderActivityChangedStatus * | status | ||
| ) |
<<extension>> Get the reliable reader activity changed status for this writer.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_ReliableReaderActivityChangedStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_datawriter_cache_status | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterCacheStatus * | status | ||
| ) |
<<extension>> Get the datawriter cache status for this writer.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_DataWriterCacheStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_datawriter_protocol_status | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterProtocolStatus * | status | ||
| ) |
<<extension>> Get the datawriter protocol status for this writer.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_DataWriterProtocolStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_datawriter_protocol_status | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterProtocolStatus * | status, | ||
| const DDS_InstanceHandle_t * | subscription_handle | ||
| ) |
<<extension>> Get the datawriter protocol status for this writer, per matched subscription identified by the subscription_handle.
This also resets the status so that it is no longer considered changed.
Note: Status for a remote entity is only kept while the entity is alive. Once a remote entity is no longer alive, its status is deleted.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_DataWriterProtocolStatus to be filled in. Cannot be NULL. |
| subscription_handle | <<in>> Handle to a specific subscription associated with the DDS_DataReader. Cannot be NULL. Must correspond to a subscription currently associated with the DDS_DataWriter. |
| DDS_ReturnCode_t DDS_DataWriter_get_matched_subscription_datawriter_protocol_status_by_locator | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterProtocolStatus * | status, | ||
| const struct DDS_Locator_t * | locator | ||
| ) |
<<extension>> Get the datawriter protocol status for this writer, per matched subscription identified by the locator.
This also resets the status so that it is no longer considered changed.
Note: Status for a remote entity is only kept while the entity is alive. Once a remote entity is no longer alive, its status is deleted.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_DataWriterProtocolStatus to be filled in Cannot be NULL. |
| locator | <<in>> Locator to a specific locator associated with the DDS_DataReader. Cannot be NULL. Must correspond to a locator of one or more subscriptions currently associated with the DDS_DataWriter. |
| DDS_ReturnCode_t DDS_DataWriter_get_service_request_accepted_status | ( | DDS_DataWriter * | self, |
| struct DDS_ServiceRequestAcceptedStatus * | status | ||
| ) |
Accesses the DDS_SERVICE_REQUEST_ACCEPTED_STATUS communication status.
This also resets the status so that it is no longer considered changed.
| self | <<in>> Cannot be NULL. |
| status | <<inout>> DDS_ServiceRequestAcceptedStatus to be filled in. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_set_qos | ( | DDS_DataWriter * | self, |
| const struct DDS_DataWriterQos * | qos | ||
| ) |
Sets the writer QoS.
This operation modifies the QoS of the DDS_DataWriter.
The DDS_DataWriterQos::user_data, DDS_DataWriterQos::deadline, DDS_DataWriterQos::latency_budget, DDS_DataWriterQos::ownership_strength, DDS_DataWriterQos::transport_priority, DDS_DataWriterQos::lifespan and DDS_DataWriterQos::writer_data_lifecycle can be changed. The other policies are immutable.
| self | <<in>> Cannot be NULL. |
| qos | <<in>> The DDS_DataWriterQos to be set to. Policies must be consistent. Immutable policies cannot be changed after DDS_DataWriter is enabled. The special value DDS_DATAWRITER_QOS_DEFAULT can be used to indicate that the QoS of the DDS_DataWriter should be changed to match the current default DDS_DataWriterQos set in the DDS_Publisher. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_set_qos_with_profile | ( | DDS_DataWriter * | self, |
| const char * | library_name, | ||
| const char * | profile_name | ||
| ) |
<<extension>> Change the QoS of this writer using the input XML QoS profile.
This operation modifies the QoS of the DDS_DataWriter.
The DDS_DataWriterQos::user_data, DDS_DataWriterQos::deadline, DDS_DataWriterQos::latency_budget, DDS_DataWriterQos::ownership_strength, DDS_DataWriterQos::transport_priority, DDS_DataWriterQos::lifespan and DDS_DataWriterQos::writer_data_lifecycle can be changed. The other policies are immutable.
| self | <<in>> Cannot be NULL. |
| library_name | <<in>> Library name containing the XML QoS profile. If library_name is null RTI Connext will use the default library (see DDS_Publisher_set_default_library). |
| profile_name | <<in>> XML QoS Profile name. If profile_name is null RTI Connext will use the default profile (see DDS_Publisher_set_default_profile). |
| DDS_ReturnCode_t DDS_DataWriter_get_qos | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterQos * | qos | ||
| ) |
Gets the writer QoS.
This function may potentially allocate memory depending on the sequences contained in some QoS policies.
| self | <<in>> Cannot be NULL. |
| qos | <<inout>> The DDS_DataWriterQos to be filled up. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_set_property | ( | DDS_DataWriter * | self, |
| const char * | property_name, | ||
| const char * | value, | ||
| DDS_Boolean | propagate | ||
| ) |
Set the value for a property that applies to a DataWriter.
| self | <<in>> Cannot be NULL. |
| property_name | <<in>>. Name of the property that you want to set. |
| value | <<in>>. New value for the property. |
| propagate | <<in>>. Indicates if the property will be propagated or not. |
| DDS_ReturnCode_t DDS_DataWriter_set_listener | ( | DDS_DataWriter * | self, |
| const struct DDS_DataWriterListener * | l, | ||
| DDS_StatusMask | mask | ||
| ) |
Sets the writer listener.
| self | <<in>> Cannot be NULL. |
| l | <<in>> DDS_DataWriterListener to set to |
| mask | <<in>> DDS_StatusMask associated with the DDS_DataWriterListener. The callback function on the listener cannot be NULL if the corresponding status is turned on in the mask. |
| struct DDS_DataWriterListener DDS_DataWriter_get_listener | ( | DDS_DataWriter * | self | ) |
Get the writer listener.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_get_listenerX | ( | DDS_DataWriter * | self, |
| struct DDS_DataWriterListener * | listener | ||
| ) |
<<extension>> Get the writer listener.
An alternative form of get_listener that fills in an existing listener structure rather than returning one on the stack.
| self | <<in>> Cannot be NULL. |
| listener | <<inout>> DDS_DataWriterListener structure to be filled up. Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_flush | ( | DDS_DataWriter * | self | ) |
<<extension>> Flushes the batch in progress in the context of the calling thread.
After being flushed, the batch is available to be sent on the network.
If the DDS_DataWriter does not have DDS_PublishModeQosPolicy kind set to DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS, the batch will be sent on the network immediately (in the context of the calling thread).
If the DDS_DataWriter does have DDS_PublishModeQosPolicy kind set to DDS_ASYNCHRONOUS_PUBLISH_MODE_QOS, the batch will be sent in the context of the asynchronous publishing thread.
This operation may block in the same conditions as FooDataWriter_write.
If this operation does block, the RELIABILITY max_blocking_time configures the maximum time the write operation may block (waiting for space to become available). If max_blocking_time elapses before the DDS_DataWriter is able to store the modification without exceeding the limits, the operation will fail with DDS_RETCODE_TIMEOUT.
| self | <<in>> Cannot be NULL. |
| DDS_ReturnCode_t DDS_DataWriter_take_discovery_snapshot | ( | DDS_DataWriter * | self, |
| const char * | file_name | ||
| ) |
Take a snapshot of the compatible and incompatible remote readers matched by a local writer.
A possible output may be the following:
| self | <<in>> The local writer. |
| file_name | <<in>> Name of the file where snapshot should be printed. If NULL, the snapshot will be printed through NDDS_Config_Logger. Otherwise, the snapshot will be printed in the file specified by file_name. |