DdsDcpsCore.idl

Go to the documentation of this file.

/*
 *
 *
 * Distributed under the OpenDDS License.
 * See: http://www.opendds.org/license.html
 */

#ifndef OPENDDS_DCPS_CORE_IDL
#define OPENDDS_DCPS_CORE_IDL

// The includes below are needed to deal with compilers that
// have ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT
#include "tao/StringSeq.pidl"
#include "tao/LongSeq.pidl"

#define HANDLE_TYPE_NATIVE long
#define BUILTIN_TOPIC_KEY_TYPE_NATIVE long

module DDS {
// Make the IDL compiler produce include of zero-copy read info
// sequence template.
#pragma DCPS_SUPPORT_ZERO_COPY_READ

    typedef sequence<string> StringSeq;
    typedef HANDLE_TYPE_NATIVE    InstanceHandle_t;
    typedef BUILTIN_TOPIC_KEY_TYPE_NATIVE BuiltinTopicKeyValue[3];

    typedef sequence<InstanceHandle_t> InstanceHandleSeq;

    typedef long QosPolicyId_t;

    struct QosPolicyCount {
                QosPolicyId_t policy_id;
                long count;
                };

    typedef sequence<QosPolicyCount> QosPolicyCountSeq;

    typedef sequence<octet> OctetSeq;

    struct Duration_t {
                long sec;
                unsigned long nanosec;
                };

    const long            DURATION_INFINITE_SEC   = 0x7fffffff;
    const unsigned long   DURATION_INFINITE_NSEC  = 0x7fffffff;

    const long DURATION_ZERO_SEC = 0;
    const unsigned long DURATION_ZERO_NSEC = 0;

    // Property_t, PropertySeq, BinaryProperty_t, BinaryPropertySeq, and PropertyQosPolicy
    // are all part of the security specification (ptc/2017-09-26).
    // These structs/typedefs are in this file to satisfy dependencies for
    // DomainParticipantQos (which was extended in the security specification).
    struct Property_t {
      string name;
      string value;
      boolean propagate;
    };
    typedef sequence<Property_t> PropertySeq;

    struct BinaryProperty_t {
      string name;
      OctetSeq value;
      boolean propagate;
    };
    typedef sequence<BinaryProperty_t> BinaryPropertySeq;

    //@extensibility(APPENDABLE)
    struct PropertyQosPolicy {
        PropertySeq        value;
        BinaryPropertySeq  binary_value;
    };

    struct UserDataQosPolicy {
                OctetSeq value;
                };

    struct GroupDataQosPolicy {
                OctetSeq value;
                };

    struct TopicDataQosPolicy {
                OctetSeq value;
                };

    struct PartitionQosPolicy {
                StringSeq name;
                };

    enum HistoryQosPolicyKind {
                KEEP_LAST_HISTORY_QOS,
                KEEP_ALL_HISTORY_QOS
                };

    enum DurabilityQosPolicyKind {
                VOLATILE_DURABILITY_QOS,
                TRANSIENT_LOCAL_DURABILITY_QOS,
                TRANSIENT_DURABILITY_QOS,
                PERSISTENT_DURABILITY_QOS
                };

    struct DurabilityQosPolicy {
                DurabilityQosPolicyKind kind;
                };

    struct DurabilityServiceQosPolicy {
        Duration_t              service_cleanup_delay;
        HistoryQosPolicyKind    history_kind;
        long                    history_depth;
        long                    max_samples;
        long                    max_instances;
        long                    max_samples_per_instance;
    };

    struct DeadlineQosPolicy {
                Duration_t period;
                };

    struct LatencyBudgetQosPolicy {
                Duration_t duration;
                };

    enum LivelinessQosPolicyKind {
                AUTOMATIC_LIVELINESS_QOS,
                MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
                MANUAL_BY_TOPIC_LIVELINESS_QOS
                };

    struct LivelinessQosPolicy {
                LivelinessQosPolicyKind kind;
                Duration_t lease_duration;
                };

    enum ReliabilityQosPolicyKind {
                BEST_EFFORT_RELIABILITY_QOS,
                RELIABLE_RELIABILITY_QOS
                };

    struct ReliabilityQosPolicy {
                ReliabilityQosPolicyKind kind;
                Duration_t max_blocking_time;
                };

    enum DestinationOrderQosPolicyKind {
                BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS,
                BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
                };

    struct DestinationOrderQosPolicy {
                DestinationOrderQosPolicyKind kind;
                };

    struct HistoryQosPolicy {
                HistoryQosPolicyKind kind;
                long depth;
                };

    struct ResourceLimitsQosPolicy {
                long max_samples;
                long max_instances;
                long max_samples_per_instance;
                };

    struct TransportPriorityQosPolicy {
                long value;
                };

    struct LifespanQosPolicy {
                Duration_t duration;
                };

    enum OwnershipQosPolicyKind {
                SHARED_OWNERSHIP_QOS,
                EXCLUSIVE_OWNERSHIP_QOS
                };

    struct OwnershipQosPolicy {
                OwnershipQosPolicyKind kind;
                };

    struct OwnershipStrengthQosPolicy {
                long value;
                };

    enum PresentationQosPolicyAccessScopeKind {
                INSTANCE_PRESENTATION_QOS,
                TOPIC_PRESENTATION_QOS,
                GROUP_PRESENTATION_QOS
                };

    struct PresentationQosPolicy {
                PresentationQosPolicyAccessScopeKind access_scope;
                boolean coherent_access;
                boolean ordered_access;
                };

    struct TimeBasedFilterQosPolicy {
                Duration_t minimum_separation;
                };

    struct TopicQos {
                TopicDataQosPolicy topic_data;
                DurabilityQosPolicy durability;
                DurabilityServiceQosPolicy durability_service;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                DestinationOrderQosPolicy destination_order;
                HistoryQosPolicy history;
                ResourceLimitsQosPolicy resource_limits;
                TransportPriorityQosPolicy transport_priority;
                LifespanQosPolicy lifespan;
                OwnershipQosPolicy ownership;
                };

    struct WriterDataLifecycleQosPolicy {
                boolean autodispose_unregistered_instances;
                };

    struct DataWriterQos {
                DurabilityQosPolicy durability;
                DurabilityServiceQosPolicy durability_service;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                DestinationOrderQosPolicy destination_order;
                HistoryQosPolicy history;
                ResourceLimitsQosPolicy resource_limits;
                TransportPriorityQosPolicy transport_priority;
                LifespanQosPolicy lifespan;
                UserDataQosPolicy user_data;
                OwnershipQosPolicy ownership;
                OwnershipStrengthQosPolicy ownership_strength;
                WriterDataLifecycleQosPolicy writer_data_lifecycle;
                };

    struct EntityFactoryQosPolicy {
                boolean autoenable_created_entities;
                };

    struct PublisherQos {
                PresentationQosPolicy presentation;
                PartitionQosPolicy partition;
                GroupDataQosPolicy group_data;
                EntityFactoryQosPolicy entity_factory;
                };

    struct ReaderDataLifecycleQosPolicy {
                Duration_t autopurge_nowriter_samples_delay;
                Duration_t autopurge_disposed_samples_delay;
                };

    struct DataReaderQos {
                DurabilityQosPolicy durability;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                DestinationOrderQosPolicy destination_order;
                HistoryQosPolicy history;
                ResourceLimitsQosPolicy resource_limits;
                UserDataQosPolicy user_data;
                OwnershipQosPolicy ownership;
                TimeBasedFilterQosPolicy time_based_filter;
                ReaderDataLifecycleQosPolicy reader_data_lifecycle;
                };

    struct SubscriberQos {
                PresentationQosPolicy presentation;
                PartitionQosPolicy partition;
                GroupDataQosPolicy group_data;
                EntityFactoryQosPolicy entity_factory;
                };

    struct DomainParticipantFactoryQos {
                EntityFactoryQosPolicy entity_factory;
                };

    struct DomainParticipantQos {
                UserDataQosPolicy user_data;
                EntityFactoryQosPolicy entity_factory;
                PropertyQosPolicy property; // DDS-Security 1.1 ptc/2017-09-26
                };

    struct BuiltinTopicKey_t {
                BuiltinTopicKeyValue value;
                };

    // ----------------------------------------------------------------------
#if !defined (DDS_HAS_MINIMUM_BIT)
// These pragmas are OpenDDS-specific.
#pragma DCPS_DATA_TYPE "DDS::ParticipantBuiltinTopicData"
#pragma DCPS_DATA_KEY  "DDS::ParticipantBuiltinTopicData key.value[0]"
#pragma DCPS_DATA_KEY  "DDS::ParticipantBuiltinTopicData key.value[1]"
#pragma DCPS_DATA_KEY  "DDS::ParticipantBuiltinTopicData key.value[2]"
#endif

    struct ParticipantBuiltinTopicData {
      BuiltinTopicKey_t key;
      UserDataQosPolicy user_data;
    };

#if !defined (DDS_HAS_MINIMUM_BIT)
// These pragmas are OpenDDS-specific.
#pragma DCPS_DATA_TYPE "DDS::PublicationBuiltinTopicData"
#pragma DCPS_DATA_KEY  "DDS::PublicationBuiltinTopicData key.value[0]"
#pragma DCPS_DATA_KEY  "DDS::PublicationBuiltinTopicData key.value[1]"
#pragma DCPS_DATA_KEY  "DDS::PublicationBuiltinTopicData key.value[2]"
#endif
    struct PublicationBuiltinTopicData {
                BuiltinTopicKey_t key;
                BuiltinTopicKey_t participant_key;
                string topic_name;
                string type_name;
                DurabilityQosPolicy durability;
                DurabilityServiceQosPolicy durability_service;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                LifespanQosPolicy lifespan;
                UserDataQosPolicy user_data;
                OwnershipQosPolicy ownership;
                OwnershipStrengthQosPolicy ownership_strength;
                DestinationOrderQosPolicy destination_order;
                PresentationQosPolicy presentation;
                PartitionQosPolicy partition;
                TopicDataQosPolicy topic_data;
                GroupDataQosPolicy group_data;
                };

#if !defined (DDS_HAS_MINIMUM_BIT)
// These pragmas are OpenDDS-specific.
#pragma DCPS_DATA_TYPE "DDS::SubscriptionBuiltinTopicData"
#pragma DCPS_DATA_KEY  "DDS::SubscriptionBuiltinTopicData key.value[0]"
#pragma DCPS_DATA_KEY  "DDS::SubscriptionBuiltinTopicData key.value[1]"
#pragma DCPS_DATA_KEY  "DDS::SubscriptionBuiltinTopicData key.value[2]"
#endif
    struct SubscriptionBuiltinTopicData {
                BuiltinTopicKey_t key;
                BuiltinTopicKey_t participant_key;
                string topic_name;
                string type_name;
                DurabilityQosPolicy durability;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                OwnershipQosPolicy ownership;
                DestinationOrderQosPolicy destination_order;
                UserDataQosPolicy user_data;
                TimeBasedFilterQosPolicy time_based_filter;
                PresentationQosPolicy presentation;
                PartitionQosPolicy partition;
                TopicDataQosPolicy topic_data;
                GroupDataQosPolicy group_data;
                };

#if !defined (DDS_HAS_MINIMUM_BIT)
// These pragmas are OpenDDS-specific.
#pragma DCPS_DATA_TYPE "DDS::TopicBuiltinTopicData"
#pragma DCPS_DATA_KEY  "DDS::TopicBuiltinTopicData key.value[0]"
#pragma DCPS_DATA_KEY  "DDS::TopicBuiltinTopicData key.value[1]"
#pragma DCPS_DATA_KEY  "DDS::TopicBuiltinTopicData key.value[2]"
#endif

    struct TopicBuiltinTopicData {
                BuiltinTopicKey_t key;
                string name;
                string type_name;
                DurabilityQosPolicy durability;
                DurabilityServiceQosPolicy durability_service;
                DeadlineQosPolicy deadline;
                LatencyBudgetQosPolicy latency_budget;
                LivelinessQosPolicy liveliness;
                ReliabilityQosPolicy reliability;
                TransportPriorityQosPolicy transport_priority;
                LifespanQosPolicy lifespan;
                DestinationOrderQosPolicy destination_order;
                HistoryQosPolicy history;
                ResourceLimitsQosPolicy resource_limits;
                OwnershipQosPolicy ownership;
                TopicDataQosPolicy topic_data;
                };

    // Sample states to support reads
    typedef unsigned long SampleStateKind;

    const SampleStateKind READ_SAMPLE_STATE = 0x0001 << 0;
    const SampleStateKind NOT_READ_SAMPLE_STATE = 0x0001 << 1;

    // This is a bit-mask SampleStateKind
    typedef unsigned long SampleStateMask;
    const SampleStateMask ANY_SAMPLE_STATE = 0xffff;

    // View states to support reads
    typedef unsigned long ViewStateKind;
    const ViewStateKind NEW_VIEW_STATE = 0x0001 << 0;
    const ViewStateKind NOT_NEW_VIEW_STATE = 0x0001 << 1;

    // This is a bit-mask ViewStateKind
    typedef unsigned long ViewStateMask;
    const ViewStateMask ANY_VIEW_STATE = 0xffff;

    // Instance states to support reads
    typedef unsigned long InstanceStateKind;
    const InstanceStateKind ALIVE_INSTANCE_STATE = 0x0001 << 0;
    const InstanceStateKind NOT_ALIVE_DISPOSED_INSTANCE_STATE   = 0x0001 << 1;
    const InstanceStateKind NOT_ALIVE_NO_WRITERS_INSTANCE_STATE = 0x0001 << 2;

    // This is a bit-mask InstanceStateKind
    typedef unsigned long InstanceStateMask;
    const InstanceStateMask ANY_INSTANCE_STATE                  = 0xffff;
    const InstanceStateMask NOT_ALIVE_INSTANCE_STATE            = 0x006;

    struct Time_t {
                long sec;
                unsigned long nanosec;
                };

    const long            TIME_INVALID_SEC        = -1;
    const unsigned long   TIME_INVALID_NSEC       = 0xffffffff;

    struct SampleInfo {
                SampleStateKind sample_state;
                ViewStateKind view_state;
                InstanceStateKind instance_state;
                Time_t source_timestamp;
                InstanceHandle_t instance_handle;
                InstanceHandle_t publication_handle;
                long disposed_generation_count;
                long no_writers_generation_count;
                long sample_rank;
                long generation_rank;
                long absolute_generation_rank;
                boolean valid_data;
                long long opendds_reserved_publication_seq;
                };

  typedef sequence<SampleInfo> SampleInfoSeq;

};

#endif  /* OPENDDS_DCPS_CORE_IDL */