dds_c_publication.h

Go to the documentation of this file.

/*
 * FILE: dds_c_publication.h - DDS publication module
 *
 * (c) Copyright, Real-Time Innovations, 2012-2014.
 *
 * All rights reserved.
 *
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 *
 * Modification History
 * --------------------
 * 20sep2014,as Explicitly define public support functions for Status types
 * 07may2014,as MICRO-784 Expose get_X_status API in C++
 * 19mar2014,tk MICRO-74: Support endpoint specific transport
 * 04mar2014,tk MICRO-84: Added C listener for writer-side notification of
 *                        unacknowledged samples
 * 19jul2013,as Added support for C++
 * 06feb2013,eh MICRO-262: add writer_resource_limits
 * 30apr2012,tk Written
 */
/*ce
 * \file
 * \brief DDS publication module
 */
/*e
  @addtogroup DDSPublicationModule
  @ingroup DDSCModule

  @brief Defines the \dds publication package
*/
#ifndef dds_c_publication_h
#define dds_c_publication_h

#include "dds_c_sequence.h"

#ifndef db_api_h
#include "db/db_api.h"
#endif
#ifndef dds_c_topic_h
#include "dds_c/dds_c_topic.h"
#endif

#ifdef __cplusplus
extern "C"
{
#endif


/* ================================================================= */
/*                         Typedef for DataWriter                    */
/* ================================================================= */

/*ce \dref_DataWriter
 */
typedef struct DDS_DataWriterImpl DDS_DataWriter;

/* ================================================================= */
/*                         Typedef for Publisher                     */
/* ================================================================= */

/*ce \dref_Publisher
 */
typedef struct DDS_PublisherImpl DDS_Publisher;

/*i @ingroup DDSPublicationModule
  @brief Pointer to DDS_Publisher.
 */
typedef DDS_Publisher *DDS_Publisher_ptr;

DDS_SEQUENCE(DDS_PublisherSeq, DDS_Publisher_ptr)

#ifdef DOXYGEN_DOCUMENTATION_ONLY
/*ce \dref_PublisherSeq
 */
struct DDS_PublisherSeq {};
#endif

/* ================================================================= */
/*                             Status                                */
/* ================================================================= */

/*e \dref_OfferedDeadlineMissedStatus
 */
struct DDS_OfferedDeadlineMissedStatus
{
    /*e \dref_OfferedDeadlineMissedStatus_total_count
     *
     * \brief total count
     */
    DDS_Long total_count;

    /*e \dref_OfferedDeadlineMissedStatus_total_count_change
     */
    DDS_Long total_count_change;

    /*e \dref_OfferedDeadlineMissedStatus_last_instance_handle
     */
    DDS_InstanceHandle_t last_instance_handle;

    DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_OfferedDeadlineMissedStatus)
};

/*ce \dref_OfferedDeadlineMissedStatus_INITIALIZER
 */
#define DDS_OfferedDeadlineMissedStatus_INITIALIZER \
                { 0L, 0L, DDS_HANDLE_NIL_NATIVE }

/*ci \dref_OfferedDeadlineMissedStatus_reset
 */
#define DDS_OfferedDeadlineMissedStatus_reset(_s) \
{\
    (_s)->total_count_change = 0;\
}

/* ----------------------------------------------------------------- */

/*e \dref_LivelinessLostStatus
 */
struct DDS_LivelinessLostStatus
{
    /*e \dref_LivelinessLostStatus_total_count
     */
    DDS_Long total_count;

    /*e \dref_LivelinessLostStatus_total_count_change
     */
    DDS_Long total_count_change;

    DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_LivelinessLostStatus)
};

/*ce \dref_LivelinessLostStatus_INITIALIZER
 */
#define DDS_LivelinessLostStatus_INITIALIZER { 0L, 0L }

/*ci \dref_LivelinessLostStatus_reset
 */
#define DDS_LivelinessLostStatus_reset(_s) \
{\
    (_s)->total_count_change = 0;\
}

/* ----------------------------------------------------------------- */

/*e \dref_OfferedIncompatibleQosStatus
 */
struct DDS_OfferedIncompatibleQosStatus
{
    /*e \dref_OfferedIncompatibleQosStatus_total_count
     */
    DDS_Long total_count;

    /*e \dref_OfferedIncompatibleQosStatus_total_count_change
     */
    DDS_Long total_count_change;

    /*e \dref_OfferedIncompatibleQosStatus_last_policy_id
     */
    DDS_QosPolicyId_t last_policy_id;

    /*e \dref_OfferedIncompatibleQosStatus_policies
     */
    struct DDS_QosPolicyCountSeq policies;

    DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_OfferedIncompatibleQosStatus)
};

/*ce \dref_OfferedIncompatibleQosStatus_INITIALIZER
 */
#define DDS_OfferedIncompatibleQosStatus_INITIALIZER \
        { 0L, 0L,DDS_INVALID_QOS_POLICY_ID, DDS_SEQUENCE_INITIALIZER(struct DDS_QosPolicyCount) }

/*ci \dref_OfferedIncompatibleQosStatus_reset
 */
#define DDS_OfferedIncompatibleQosStatus_reset(_s) \
{\
    (_s)->total_count_change = 0;\
}

/* ----------------------------------------------------------------- */

/*e \dref_PublicationMatchedStatus
 */
struct DDS_PublicationMatchedStatus
{
    /*e \dref_PublicationMatchedStatus_total_count
     */
    DDS_Long total_count;

    /*e \dref_PublicationMatchedStatus_total_count_change
     */
    DDS_Long total_count_change;

    /*e \dref_PublicationMatchedStatus_current_count
     */
    DDS_Long current_count;

    /*e \dref_PublicationMatchedStatus_current_count_change
     */
    DDS_Long current_count_change;

    /*e \dref_PublicationMatchedStatus_last_subscription_handle
     */
    DDS_InstanceHandle_t last_subscription_handle;

    DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_PublicationMatchedStatus)
};

/*ce \dref_PublicationMatchedStatus_INITIALIZER
 */
#define DDS_PublicationMatchedStatus_INITIALIZER \
        { 0L, 0L, 0L, 0L, DDS_HANDLE_NIL_NATIVE }

/*ci \dref_PublicationMatchedStatus_reset
 */
#define DDS_PublicationMatchedStatus_reset(_s) \
{\
    (_s)->total_count_change = 0;\
    (_s)->current_count_change = 0;\
}

/* ------------------------------------------------------------------------ */

/*e \dref_ReliableReaderActivityChangedStatus
 */
struct DDS_ReliableReaderActivityChangedStatus
{
    /*e \dref_ReliableReaderActivityChangedStatus_active_count
     */
    DDS_Long active_count;

    /*e \dref_ReliableReaderActivityChangedStatus_inactive_count
     */
    DDS_Long inactive_count;

    /*e \dref_ReliableReaderActivityChangedStatus_active_count_change
     */
    DDS_Long active_count_change;

    /*e \dref_ReliableReaderActivityChangedStatus_inactive_count_change
     */
    DDS_Long inactive_count_change;

    /*e \dref_ReliableReaderActivityChangedStatus_last_instance_handle
     */
    DDS_InstanceHandle_t last_instance_handle;

    DDSC_CPP_SUPPORT_METHODS_BASIC(DDS_ReliableReaderActivityChangedStatus)
};

/*e \dref_ReliableReaderActivityChangedStatus_INITIALIZER
 */
#define DDS_ReliableReaderActivityChangedStatus_INITIALIZER \
        {0, 0, 0, 0,DDS_HANDLE_NIL_NATIVE}

/*ci \dref_ReliableReaderActivityChangedStatus_reset
 */
#define DDS_ReliableReaderActivityChangedStatus_reset(_s) \
{\
    (_s)->active_count_change = 0;\
    (_s)->inactive_count_change = 0;\
}

/* ------------------------------------------------------------------------ */

/*i \dref_ReliableSampleUnacknowledgedStatus
 */
struct DDS_ReliableSampleUnacknowledgedStatus
{
    /*i \dref_ReliableSampleUnacknowledgedStatus_sequence_number
     */
    struct DDS_SequenceNumber_t sequence_number;

    /*i \dref_ReliableSampleUnacknowledgedStatus_unacknowledged_count
     */
    DDS_Long unacknowledged_count;

    /*i \dref_ReliableSampleUnacknowledgedStatus_instance_handle
     */
    DDS_InstanceHandle_t instance_handle;
};

/*i \dref_ReliableSampleUnacknowledgedStatus_INITIALIZER
 */
#define DDS_ReliableSampleUnacknowledgedStatus_INITIALIZER \
{\
    {0,0},\
    0,\
    DDS_HANDLE_NIL_NATIVE\
}

/*i \dref_OfferedDeadlineMissedStatus_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_OfferedDeadlineMissedStatus_initialize(
            struct DDS_OfferedDeadlineMissedStatus *self);

/*i \dref_OfferedIncompatibleQosStatus_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_OfferedIncompatibleQosStatus_initialize(
            struct DDS_OfferedIncompatibleQosStatus *self);

/*i \dref_PublicationMatchedStatus_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_PublicationMatchedStatus_initialize(
            struct DDS_PublicationMatchedStatus *self);

/*i \dref_LivelinessLostStatus_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_LivelinessLostStatus_initialize(
            struct DDS_LivelinessLostStatus *self);

/*i \dref_ReliableReaderActivityChangedStatus_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_ReliableReaderActivityChangedStatus_initialize(
            struct DDS_ReliableReaderActivityChangedStatus *self);

/* ----------------------------------------------------------------- */

#ifdef __cplusplus
}                               /* extern "C" */
#endif

/* ================================================================= */
/*                          QoS                                      */
/* ================================================================= */

/*i \dref_DataWriterData
 */
struct DDS_DataWriterData
{
    struct DDS_LocatorSeq *unicast_locator;
};

/*e \dref_DataWriterQos
 */
struct DDS_DataWriterQos
{
    /*e \dref_DataWriterQos_deadline
     */
    struct DDS_DeadlineQosPolicy deadline;

    /*e \dref_DataWriterQos_liveliness
     */
    struct DDS_LivelinessQosPolicy liveliness;

    /*e \dref_DataWriterQos_history
     */
    struct DDS_HistoryQosPolicy history;

    /*e \dref_DataWriterQos_resource_limits
     */
    struct DDS_ResourceLimitsQosPolicy resource_limits;

    /*e \dref_DataWriterQos_ownership
     */
    struct DDS_OwnershipQosPolicy ownership;

    /*e \dref_DataWriterQos_ownership_strength
     */
    struct DDS_OwnershipStrengthQosPolicy ownership_strength;

    /*e \dref_DataWriterQos_reliability
     */
    struct DDS_ReliabilityQosPolicy reliability;

    /*e \dref_DataWriterQos_durability
     */
    struct DDS_DurabilityQosPolicy durability;

    /* --- Extensions: ---------------------------------------------------- */

    /*e \dref_DataWriterQos_protocol
     */
    struct DDS_DataWriterProtocolQosPolicy protocol;

    /*i \dref_DataWriterQos_type_support
     */
    struct DDS_TypeSupportQosPolicy type_support;

    /*e \dref_DataWriterQos_transport
     */
    struct DDS_TransportQosPolicy transport;

    /*i \dref_DataWriterQos_management
     */
    struct RTI_ManagementQosPolicy management;

    /*i \dref_DataWriterQos_writer_resource_limits 
     */
    struct DDS_DataWriterResourceLimitsQosPolicy writer_resource_limits;

    struct DDS_DataWriterData *data;

    DDSC_CPP_SUPPORT_METHODS_EXTENDED(DDS_DataWriterQos)
};

#ifdef __cplusplus
extern "C" {
#endif

/* #if INCLUDE_API_QOS */
/*ce \dref_DataWriterQos_initialize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriterQos_initialize(struct DDS_DataWriterQos *self);

/* #if INCLUDE_API_QOS */
/*ce \dref_DataWriterQos_copy
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriterQos_copy(struct DDS_DataWriterQos *self,
                       const struct DDS_DataWriterQos *source);


/*i \dref_DataWriterQos_is_equal
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_DataWriterQos_is_equal(const struct DDS_DataWriterQos *left,
                               const struct DDS_DataWriterQos *right);

#ifndef RTI_CERT
/*ce \dref_DataWriterQos_finalize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriterQos_finalize(struct DDS_DataWriterQos *self);
#endif /* !RTI_CERT */

/*ce \dref_DataWriterQos_INITIALIZER
 */
#define DDS_DataWriterQos_INITIALIZER   {                 \
    DDS_DEADLINE_QOS_POLICY_DEFAULT,                      \
    DDS_LIVELINESS_QOS_POLICY_DEFAULT,                    \
    DDS_HISTORY_QOS_POLICY_DEFAULT,                       \
    DDS_RESOURCE_LIMITS_QOS_POLICY_DEFAULT,               \
    DDS_OWNERSHIP_QOS_POLICY_DEFAULT,                     \
    DDS_OWNERSHIP_STRENGTH_QOS_POLICY_DEFAULT,            \
    DDS_RELIABILITY_QOS_POLICY_DEFAULT,                   \
    DDS_DURABILITY_QOS_POLICY_DEFAULT,                    \
    DDS_DATA_WRITER_PROTOCOL_QOS_POLICY_DEFAULT,          \
    DDS_TYPESUPPORT_QOS_POLICY_DEFAULT,                   \
    DDS_TRANSPORT_QOS_POLICY_DEFAULT,                     \
    RTI_MANAGEMENT_QOS_POLICY_DEFAULT,                    \
    DDS_DATAWRITERRESOURCE_LIMITS_QOS_POLICY_DEFAULT,     \
    NULL                                                  \
}

#ifdef __cplusplus
} /* extern "C" */
#endif

/* ----------------------------------------------------------------- */

/*e \dref_PublisherQos
 */
struct DDS_PublisherQos
{
    /*e \dref_PublisherQos_entity_factory
     */
    struct DDS_EntityFactoryQosPolicy entity_factory;

    /*i \dref_PublisherQos_management
     */
    struct RTI_ManagementQosPolicy management;

    DDSC_CPP_SUPPORT_METHODS_EXTENDED(DDS_PublisherQos)
};

#ifdef __cplusplus
extern "C" {
#endif

/*ce \dref_PublisherQos_initialize
 */
/* #if INCLUDE_API_QOS */
DDSCDllExport DDS_ReturnCode_t
DDS_PublisherQos_initialize(struct DDS_PublisherQos *self);

/*ce \dref_PublisherQos_copy
 */
DDSCDllExport DDS_ReturnCode_t
DDS_PublisherQos_copy(struct DDS_PublisherQos *self,
                      const struct DDS_PublisherQos *source);

/*i \dref_PublisherQos_is_equal
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_PublisherQos_is_equal(const struct DDS_PublisherQos *left,
                          const struct DDS_PublisherQos *right);

#ifndef RTI_CERT
/*ce \dref_PublisherQos_finalize
 */
DDSCDllExport DDS_ReturnCode_t
DDS_PublisherQos_finalize(struct DDS_PublisherQos *self);
#endif

/*ce \dref_PublisherQos_INITIALIZER
 */
#define DDS_PublisherQos_INITIALIZER   {    \
    DDS_ENTITY_FACTORY_QOS_POLICY_DEFAULT,  \
    RTI_MANAGEMENT_QOS_POLICY_DEFAULT       \
}

/* ================================================================= */
/*                       Listeners                                   */
/* ================================================================= */

/*ce \dref_DataWriterListener_OfferedDeadlineMissedCallback
 */
typedef void
(*DDS_DataWriterListener_OfferedDeadlineMissedCallback)(
        void *listener_data,
        DDS_DataWriter* writer,
        const struct DDS_OfferedDeadlineMissedStatus* status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriterListener_LivelinessLostCallback
 */
typedef void
(*DDS_DataWriterListener_LivelinessLostCallback)(
        void *listener_data,
        DDS_DataWriter *writer,
        const struct DDS_LivelinessLostStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriterListener_OfferedIncompatibleQosCallback
 */
typedef void
(*DDS_DataWriterListener_OfferedIncompatibleQosCallback)(
        void *listener_data,
        DDS_DataWriter* writer,
        const struct DDS_OfferedIncompatibleQosStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriterListener_PublicationMatchedCallback
 */
typedef void (*DDS_DataWriterListener_PublicationMatchedCallback)(
        void *listener_data,
        DDS_DataWriter *writer,
        const struct DDS_PublicationMatchedStatus *status);

/* ------------------------------------------------------------------------ */
/*e \dref_DataWriterListener_ReliableReaderActivityChangedCallback
 */
typedef void
(*DDS_DataWriterListener_ReliableReaderActivityChangedCallback)(
        void *listener_data,
        DDS_DataWriter * writer,
         const struct DDS_ReliableReaderActivityChangedStatus * status);

/* ------------------------------------------------------------------------ */
/*i \dref_DataWriterListener_ReliableSampleUnacknowledgedCallback
 */
typedef void
(*DDS_DataWriterListener_ReliableSampleUnacknowledgedCallback)(
        void *listener_data,
        DDS_DataWriter *writer,
        const struct DDS_ReliableSampleUnacknowledgedStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriterListener
 */
struct DDS_DataWriterListener
{
    /*ce \dref_DataWriterListener_as_listener
     */
    struct DDS_Listener as_listener;

    /*ce \dref_DataWriterListener_on_offered_deadline_missed
     */
    DDS_DataWriterListener_OfferedDeadlineMissedCallback
    on_offered_deadline_missed;

    /*ce \dref_DataWriterListener_on_offered_incompatible_qos
     */
    DDS_DataWriterListener_OfferedIncompatibleQosCallback
    on_offered_incompatible_qos;

    /*ce \dref_DataWriterListener_on_liveliness_lost
     */
    DDS_DataWriterListener_LivelinessLostCallback on_liveliness_lost;

    /*ce \dref_DataWriterListener_on_publication_matched
     */
    DDS_DataWriterListener_PublicationMatchedCallback
    on_publication_matched;

    /*e \dref_DataWriterListener_on_reliable_reader_activity_changed
     */
    DDS_DataWriterListener_ReliableReaderActivityChangedCallback
    on_reliable_reader_activity_changed;

    /*i \dref_DataWriterListener_on_reliable_sample_unacknowledged
     */
    DDS_DataWriterListener_ReliableSampleUnacknowledgedCallback
    on_reliable_sample_unacknowledged;
};

/*ce \dref_DataWriterListener_INITIALIZER
 */
#define DDS_DataWriterListener_INITIALIZER  { \
  DDS_Listener_INITIALIZER, \
  (DDS_DataWriterListener_OfferedDeadlineMissedCallback)NULL, \
  (DDS_DataWriterListener_OfferedIncompatibleQosCallback)NULL, \
  (DDS_DataWriterListener_LivelinessLostCallback)NULL, \
  (DDS_DataWriterListener_PublicationMatchedCallback)NULL,\
  NULL,\
  NULL\
}

/* ----------------------------------------------------------------- */
/*ce \dref_PublisherListener
 */
struct DDS_PublisherListener
{
    /*ce \dref_PublisherListener_as_datawriterlistener
     */
    struct DDS_DataWriterListener as_datawriterlistener;
};

/*ce \dref_PublisherListener_INITIALIZER
 */
#define DDS_PublisherListener_INITIALIZER   { \
    DDS_DataWriterListener_INITIALIZER }

/* ================================================================= */
/*                          Publisher                                */
/* ================================================================= */

/* ----------------------------------------------------------------- */

/*e \dref_DATAWRITER_QOS_DEFAULT
 */
extern DDSCDllVariable const struct DDS_DataWriterQos
        DDS_DATAWRITER_QOS_DEFAULT;

/* ----------------------------------------------------------------- */
#define DDS_Publisher_as_entity(publisherPtr) \
            ((DDS_Entity*) publisherPtr)

#ifdef DOXYGEN_DOCUMENTATION_ONLY
/*ce \dref_Publisher_as_entity
 */
DDS_Entity *DDS_Publisher_as_entity(DDS_Publisher * publisher);
#endif                          /*DOXYGEN_DOCUMENTATION_ONLY */

/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_Publisher_get_default_datawriter_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_get_default_datawriter_qos(
        DDS_Publisher *self,
        struct DDS_DataWriterQos *qos);

/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_Publisher_set_default_datawriter_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_set_default_datawriter_qos(
        DDS_Publisher * self,
        const struct DDS_DataWriterQos
                                                 *qos);

/* ----------------------------------------------------------------- */
/*ce \dref_Publisher_create_datawriter
 */
DDSCDllExport DDS_DataWriter*
DDS_Publisher_create_datawriter(
        DDS_Publisher *self,
        DDS_Topic *topic,
        const struct DDS_DataWriterQos *qos,
        const struct DDS_DataWriterListener *listener,
        DDS_StatusMask mask);

/* ----------------------------------------------------------------- */
/*ce \dref_Publisher_enable
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_enable(DDS_Entity *self);

/* ----------------------------------------------------------------- */
#ifndef RTI_CERT
/*ce \dref_Publisher_delete_datawriter
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_delete_datawriter(
        DDS_Publisher *self,
        DDS_DataWriter *a_datawriter);
#endif

/* ----------------------------------------------------------------- */
/*ce \dref_Publisher_lookup_datawriter
 */
/* #if INCLUDE_API_LOOKUP || RTI_CERT */
DDSCDllExport DDS_DataWriter*
DDS_Publisher_lookup_datawriter(
         DDS_Publisher *self,
         const char *topic_name);

/* ----------------------------------------------------------------- */
/*ce \dref_Publisher_get_participant
 */
DDSCDllExport DDS_DomainParticipant*
DDS_Publisher_get_participant(DDS_Publisher * self);

/* ----------------------------------------------------------------- */

/*ce \dref_Publisher_delete_contained_entities
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_delete_contained_entities(DDS_Publisher * self);


/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_Publisher_set_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_set_qos(
        DDS_Publisher *self,
        const struct DDS_PublisherQos *qos);

/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_Publisher_get_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_get_qos(
        DDS_Publisher *self,
        struct DDS_PublisherQos *qos);

/* ----------------------------------------------------------------- */
/*ce \dref_Publisher_set_listener
 */
/* called internally by Pub_new() */
DDSCDllExport DDS_ReturnCode_t
DDS_Publisher_set_listener(
        DDS_Publisher * self,
        const struct DDS_PublisherListener *l,
        DDS_StatusMask mask);


/*ce \dref_Publisher_get_listener
 */
DDSCDllExport struct DDS_PublisherListener
DDS_Publisher_get_listener(DDS_Publisher * self);

/* ================================================================= */
/*                      Data Writer                                  */
/* ================================================================= */

/* ----------------------------------------------------------------- */
#define DDS_DataWriter_as_entity(dataWriterPtr) \
            ((DDS_Entity*) dataWriterPtr)

#ifdef DOXYGEN_DOCUMENTATION_ONLY
/*ce \dref_DataWriter_as_entity
 */
DDS_Entity *DDS_DataWriter_as_entity(DDS_DataWriter * dataWriter);
#endif                          /*DOXYGEN_DOCUMENTATION_ONLY */

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_enable
*/
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_enable(DDS_Entity *self);

/*ce \dref_DataWriter_assert_liveliness
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_assert_liveliness(DDS_DataWriter * self);

/* ----------------------------------------------------------------- */
#if INCLUDE_API_LOOKUP
/*ce \dref_DataWriter_get_matched_subscriptions
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_matched_subscriptions(
        DDS_DataWriter *self,
        struct DDS_InstanceHandleSeq *subscription_handles);
#endif /* INCLUDE_API_LOOKUP */

struct DDS_SubscriptionBuiltinTopicData;

/* ----------------------------------------------------------------- */
#if INCLUDE_API_LOOKUP
/*ce \dref_DataWriter_get_matched_subscription_data
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_matched_subscription_data(
        DDS_DataWriter *self,
        struct DDS_SubscriptionBuiltinTopicData *subscription_data,
        const DDS_InstanceHandle_t *subscription_handle);
#endif /* INCLUDE_API_LOOKUP */

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_topic
 */
DDSCDllExport DDS_Topic*
DDS_DataWriter_get_topic(DDS_DataWriter *self);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_publisher
 */
DDSCDllExport DDS_Publisher*
DDS_DataWriter_get_publisher(DDS_DataWriter * self);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_liveliness_lost_status
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_liveliness_lost_status(
        DDS_DataWriter *self,
        struct DDS_LivelinessLostStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_offered_deadline_missed_status
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_offered_deadline_missed_status(
        DDS_DataWriter *self,
        struct DDS_OfferedDeadlineMissedStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_offered_incompatible_qos_status
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_offered_incompatible_qos_status(
        DDS_DataWriter *self,
        struct DDS_OfferedIncompatibleQosStatus *status);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_get_publication_matched_status
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_publication_matched_status(
        DDS_DataWriter *self,
        struct DDS_PublicationMatchedStatus *status);

/* ------------------------------------------------------------------------ */
/*e \dref_DataWriter_get_reliable_reader_activity_changed_status
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_reliable_reader_activity_changed_status(
        DDS_DataWriter *self,
        struct DDS_ReliableReaderActivityChangedStatus *status);

/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_DataWriter_set_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_set_qos(
        DDS_DataWriter *self,
        const struct DDS_DataWriterQos *qos);


/* ----------------------------------------------------------------- */
/* #if INCLUDE_API_QOS */
/*ce \dref_DataWriter_get_qos
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_get_qos(DDS_DataWriter *self,
        struct DDS_DataWriterQos *qos);

/* ----------------------------------------------------------------- */
/*ce \dref_DataWriter_set_listener
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_set_listener(
        DDS_DataWriter * self,
        const struct DDS_DataWriterListener *l,
        DDS_StatusMask mask);


/*ce \dref_DataWriter_get_listener
 */
DDSCDllExport struct DDS_DataWriterListener
DDS_DataWriter_get_listener(DDS_DataWriter * self);


/********************* Untyped Writer API ****************************/
/* #ifdef INCLUDE_API_INSTANCE */
/*e \dref_DataWriter_register_instance
 */
DDSCDllExport DDS_InstanceHandle_t
DDS_DataWriter_register_instance(
        DDS_DataWriter * self,
        const void *instance_data);

/* #ifdef INCLUDE_API_INSTANCE */
/*e \dref_DataWriter_register_instance_w_timestamp
 */
DDSCDllExport DDS_InstanceHandle_t
DDS_DataWriter_register_instance_w_timestamp(
        DDS_DataWriter * self,
        const void *instance_data,
        const struct DDS_Time_t *source_timestamp);

/* #ifdef INCLUDE_API_INSTANCE */
/*ce \dref_DataWriter_unregister_instance
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_unregister_instance(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t *handle);

/* #ifdef INCLUDE_API_INSTANCE */
/*ce \dref_DataWriter_unregister_instance_w_timestamp
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_unregister_instance_w_timestamp(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t *handle,
        const struct DDS_Time_t *source_timestamp);

/* #ifdef INCLUDE_API_INSTANCE */
/*ce \dref_DataWriter_dispose
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_dispose(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t *handle);

/*ce \dref_DataWriter_dispose_w_timestamp
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_dispose_w_timestamp(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t *handle,
        const struct DDS_Time_t *source_timestamp);

/*ce \dref_DataWriter_write
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_write(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t * handle);

/*ce \dref_DataWriter_write_w_timestamp
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_write_w_timestamp(
        DDS_DataWriter *self,
        const void *instance_data,
        const DDS_InstanceHandle_t *handle,
        const struct DDS_Time_t *source_timestamp);

/*ce \dref_DataWriter_write_w_params
 */
DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_write_w_params(
        DDS_DataWriter *self,
        const void *instance_data,
        struct DDS_WriteParams_t *params);

/*i \dref_DataWriteR_get_liveliness_count
 */
DDSCDllExport DDS_Long
DDS_DataWriter_get_liveliness_count(DDS_DataWriter * self);

/****************** Additional Internal APIs **************************/

/*i \dref_DataWriter_advance_sn
 */
MUST_CHECK_RETURN DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_advance_sn(DDS_DataWriter * self);

/*i \dref_DataWriter_add_anonymous_locator
 */
MUST_CHECK_RETURN DDSCDllExport DDS_ReturnCode_t
DDS_DataWriter_add_anonymous_locator(DDS_DataWriter * self,
                                     struct DDS_Locator_t *locator);

/*i \dref_DataWriter_add_anonymous_peer
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_DataWriter_add_anonymous_peer(DDS_DataWriter *datawriter,
                                  struct NETIO_Address *dst_reader,
                                  const char *address);

/*i \dref_DataWriter_delete_anonymous_peer
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_DataWriter_delete_anonymous_peer(DDS_DataWriter *datawriter,
                                      struct NETIO_Address *dst_reader,
                                      const char *address);

/*i \dref_DataWriter_add_anonymous_route
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_DataWriter_add_anonymous_route(DDS_DataWriter *datawriter,
                                   struct NETIO_Address *dst_reader,
                                   struct NETIO_Address *via_address);

/*i \dref_DataWriter_delete_anonymous_route
 */
MUST_CHECK_RETURN DDSCDllExport DDS_Boolean
DDS_DataWriter_delete_anonymous_route(DDS_DataWriter *datawriter,
                                      struct NETIO_Address *dst_reader,
                                      struct NETIO_Address *via_address);

/* ----------------------------------------------------------------- */

#ifdef __cplusplus
}                               /* extern "C" */
#endif

#ifndef dds_c_w_history_plugin_h
#include "dds_c/dds_c_wh_plugin.h"
#endif


#endif /* dds_c_publication_h */