DdsDcpsInfrastructure.idl

Go to the documentation of this file.

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

#ifndef OPENDDS_DCPS_INFRASTRUCTURE_IDL
#define OPENDDS_DCPS_INFRASTRUCTURE_IDL

#include "dds/DdsDcpsCore.idl"
#include "dds/DdsDcpsConditionSeq.idl"

#define DOMAINID_TYPE_NATIVE long
#define HANDLE_NIL_NATIVE 0
// Implementation Note:
//   Client code must include "Service_Participant.h"
//   to have these definitions.
//#define TheParticipantFactory

// Implementation Note:
//   Client code must include "Marked_Default_Qos.h"
//   to have these definitions.
//#define PARTICIPANT_QOS_DEFAULT
//#define TOPIC_QOS_DEFAULT
//#define PUBLISHER_QOS_DEFAULT
//#define SUBSCRIBER_QOS_DEFAULT
//#define DATAWRITER_QOS_DEFAULT
//#define DATAREADER_QOS_DEFAULT
//#define DATAWRITER_QOS_USE_TOPIC_QOS
//#define DATAREADER_QOS_USE_TOPIC_QOS

#pragma ciao lem "dds/DdsDcpsInfrastructureE.idl"

module DDS {
    typedef DOMAINID_TYPE_NATIVE  DomainId_t;
    // Moved to DdsDcpsCore.idl
    // typedef HANDLE_TYPE_NATIVE    InstanceHandle_t;
    // typedef BUILTIN_TOPIC_KEY_TYPE_NATIVE BuiltinTopicKeyValue[3];
    // typedef sequence<InstanceHandle_t> InstanceHandleSeq;

    typedef long ReturnCode_t;

    // ----------------------------------------------------------------------
    // Pre-defined values
    // ----------------------------------------------------------------------
    const InstanceHandle_t HANDLE_NIL = HANDLE_NIL_NATIVE;

    const long LENGTH_UNLIMITED = -1;

    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;

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

    // ----------------------------------------------------------------------
    // Return codes
    // ----------------------------------------------------------------------
    const ReturnCode_t RETCODE_OK = 0;
    const ReturnCode_t RETCODE_ERROR = 1;
    const ReturnCode_t RETCODE_UNSUPPORTED = 2;
    const ReturnCode_t RETCODE_BAD_PARAMETER = 3;
    const ReturnCode_t RETCODE_PRECONDITION_NOT_MET = 4;
    const ReturnCode_t RETCODE_OUT_OF_RESOURCES = 5;
    const ReturnCode_t RETCODE_NOT_ENABLED = 6;
    const ReturnCode_t RETCODE_IMMUTABLE_POLICY = 7;
    const ReturnCode_t RETCODE_INCONSISTENT_POLICY = 8;
    const ReturnCode_t RETCODE_ALREADY_DELETED = 9;
    const ReturnCode_t RETCODE_TIMEOUT = 10;
    const ReturnCode_t RETCODE_NO_DATA = 11;
    const ReturnCode_t RETCODE_ILLEGAL_OPERATION     = 12;

    // ----------------------------------------------------------------------
    // Status to support listeners and conditions
    // ----------------------------------------------------------------------

    typedef unsigned long StatusKind;
    typedef unsigned long StatusMask; // bit-mask StatusKind

    const StatusKind INCONSISTENT_TOPIC_STATUS            = 0x0001 << 0;
    const StatusKind OFFERED_DEADLINE_MISSED_STATUS       = 0x0001 << 1;
    const StatusKind REQUESTED_DEADLINE_MISSED_STATUS     = 0x0001 << 2;
    const StatusKind OFFERED_INCOMPATIBLE_QOS_STATUS      = 0x0001 << 5;
    const StatusKind REQUESTED_INCOMPATIBLE_QOS_STATUS    = 0x0001 << 6;
    const StatusKind SAMPLE_LOST_STATUS                   = 0x0001 << 7;
    const StatusKind SAMPLE_REJECTED_STATUS               = 0x0001 << 8;
    const StatusKind DATA_ON_READERS_STATUS               = 0x0001 << 9;
    const StatusKind DATA_AVAILABLE_STATUS                = 0x0001 << 10;
    const StatusKind LIVELINESS_LOST_STATUS               = 0x0001 << 11;
    const StatusKind LIVELINESS_CHANGED_STATUS            = 0x0001 << 12;
    const StatusKind PUBLICATION_MATCHED_STATUS           = 0x0001 << 13;
    const StatusKind SUBSCRIPTION_MATCHED_STATUS          = 0x0001 << 14;

    struct InconsistentTopicStatus {
                long total_count;
                long total_count_change;
                };

    struct SampleLostStatus {
                long total_count;
                long total_count_change;
                };

    enum SampleRejectedStatusKind {
                NOT_REJECTED,
                REJECTED_BY_INSTANCES_LIMIT,
                REJECTED_BY_SAMPLES_LIMIT,
                REJECTED_BY_SAMPLES_PER_INSTANCE_LIMIT
                };

    struct SampleRejectedStatus {
                long total_count;
                long total_count_change;
                SampleRejectedStatusKind last_reason;
                InstanceHandle_t last_instance_handle;
                };

    struct LivelinessLostStatus {
                long total_count;
                long total_count_change;
                };

    struct LivelinessChangedStatus {
                long alive_count;
                long not_alive_count;
                long alive_count_change;
                long not_alive_count_change;
                InstanceHandle_t last_publication_handle;
                };

    struct OfferedDeadlineMissedStatus {
                long total_count;
                long total_count_change;
                InstanceHandle_t last_instance_handle;
                };

    struct RequestedDeadlineMissedStatus {
                long total_count;
                long total_count_change;
                InstanceHandle_t last_instance_handle;
                };

    struct OfferedIncompatibleQosStatus {
                long total_count;
                long total_count_change;
                QosPolicyId_t last_policy_id;
                QosPolicyCountSeq policies;
                };

    struct RequestedIncompatibleQosStatus {
                long total_count;
                long total_count_change;
                QosPolicyId_t last_policy_id;
                QosPolicyCountSeq policies;
                };


    struct PublicationMatchedStatus {
                long total_count;
                long total_count_change;
                long current_count;
                long current_count_change;
                InstanceHandle_t last_subscription_handle;
                };


    struct SubscriptionMatchedStatus {
                long total_count;
                long total_count_change;
                long current_count;
                long current_count_change;
                InstanceHandle_t last_publication_handle;
                };

    // ----------------------------------------------------------------------
    // Listeners
    // ----------------------------------------------------------------------

    local interface Listener;
    local interface Entity;
    //interface TopicDescription;
    //interface Topic;
    //interface ContentFilteredTopic;
    //interface MultiTopic;
    //interface DataWriter;
    //interface DataReader;
    //interface Subscriber;
    //interface Publisher;

    //typedef sequence<Topic> TopicSeq;
    //typedef sequence<DataReader> DataReaderSeq;

    local interface Listener {};

    // ----------------------------------------------------------------------
    // Conditions
    // ----------------------------------------------------------------------

    local interface Condition {
        boolean get_trigger_value();
    };

    // WaitSet and GuardCondition can't be expressed in IDL because they are
    // required by the spec to be default-constructable by the user
    // (07-01-01 section 7.2.2 pgh 11).  Therefore in IDL we have WaitSetInterf
    // and GuardConditionInterf.  Application code should #include
    // "dds/DCPS/WaitSet.h", "dds/DCPS/GuardCondition.h" and construct heap
    // objects with "new WaitSet()" and "new GuardCondition()".  Those objects
    // (in the DDS namespace/package) implement the interfaces described below.
    // In C++, these are reference-counted local CORBA objects.

    local interface WaitSetInterf {
        ReturnCode_t wait(
            inout ConditionSeq active_conditions,
            in Duration_t timeout);
        ReturnCode_t attach_condition(
            in Condition cond);
        ReturnCode_t detach_condition(
            in Condition cond);
        ReturnCode_t get_conditions(
            inout ConditionSeq attached_conditions);
    };

    local interface GuardConditionInterf : Condition {
        ReturnCode_t set_trigger_value(
            in boolean value);
    };


    local interface StatusCondition : Condition {
        StatusMask get_enabled_statuses();
        ReturnCode_t set_enabled_statuses(
            in StatusMask mask);
        Entity get_entity();
    };

    // ----------------------------------------------------------------------
    // Qos
    // ----------------------------------------------------------------------
    const string USERDATA_QOS_POLICY_NAME            = "UserData";
    const string DURABILITY_QOS_POLICY_NAME          = "Durability";
    const string PRESENTATION_QOS_POLICY_NAME        = "Presentation";
    const string DEADLINE_QOS_POLICY_NAME            = "Deadline";
    const string LATENCYBUDGET_QOS_POLICY_NAME       = "LatencyBudget";
    const string OWNERSHIP_QOS_POLICY_NAME           = "Ownership";
    const string OWNERSHIPSTRENGTH_QOS_POLICY_NAME   = "OwnershipStrength";
    const string LIVELINESS_QOS_POLICY_NAME          = "Liveliness";
    const string TIMEBASEDFILTER_QOS_POLICY_NAME     = "TimeBasedFilter";
    const string PARTITION_QOS_POLICY_NAME           = "Partition";
    const string RELIABILITY_QOS_POLICY_NAME         = "Reliability";
    const string DESTINATIONORDER_QOS_POLICY_NAME    = "DestinationOrder";
    const string HISTORY_QOS_POLICY_NAME             = "History";
    const string RESOURCELIMITS_QOS_POLICY_NAME      = "ResourceLimits";
    const string ENTITYFACTORY_QOS_POLICY_NAME       = "EntityFactory";
    const string WRITERDATALIFECYCLE_QOS_POLICY_NAME = "WriterDataLifecycle";
    const string READERDATALIFECYCLE_QOS_POLICY_NAME = "ReaderDataLifecycle";
    const string TOPICDATA_QOS_POLICY_NAME           = "TopicData";
    const string GROUPDATA_QOS_POLICY_NAME           = "GroupData";
    const string TRANSPORTPRIORITY_QOS_POLICY_NAME   = "TransportPriority";
    const string LIFESPAN_QOS_POLICY_NAME            = "Lifespan";
    const string DURABILITYSERVICE_POLICY_NAME       = "DurabilityService";

    const QosPolicyId_t INVALID_QOS_POLICY_ID              = 0;
    const QosPolicyId_t USERDATA_QOS_POLICY_ID            = 1;
    const QosPolicyId_t DURABILITY_QOS_POLICY_ID          = 2;
    const QosPolicyId_t PRESENTATION_QOS_POLICY_ID        = 3;
    const QosPolicyId_t DEADLINE_QOS_POLICY_ID            = 4;
    const QosPolicyId_t LATENCYBUDGET_QOS_POLICY_ID       = 5;
    const QosPolicyId_t OWNERSHIP_QOS_POLICY_ID           = 6;
    const QosPolicyId_t OWNERSHIPSTRENGTH_QOS_POLICY_ID   = 7;
    const QosPolicyId_t LIVELINESS_QOS_POLICY_ID          = 8;
    const QosPolicyId_t TIMEBASEDFILTER_QOS_POLICY_ID     = 9;
    const QosPolicyId_t PARTITION_QOS_POLICY_ID           = 10;
    const QosPolicyId_t RELIABILITY_QOS_POLICY_ID         = 11;
    const QosPolicyId_t DESTINATIONORDER_QOS_POLICY_ID    = 12;
    const QosPolicyId_t HISTORY_QOS_POLICY_ID             = 13;
    const QosPolicyId_t RESOURCELIMITS_QOS_POLICY_ID      = 14;
    const QosPolicyId_t ENTITYFACTORY_QOS_POLICY_ID       = 15;
    const QosPolicyId_t WRITERDATALIFECYCLE_QOS_POLICY_ID = 16;
    const QosPolicyId_t READERDATALIFECYCLE_QOS_POLICY_ID = 17;
    const QosPolicyId_t TOPICDATA_QOS_POLICY_ID           = 18;
    const QosPolicyId_t GROUPDATA_QOS_POLICY_ID           = 19;
    const QosPolicyId_t TRANSPORTPRIORITY_QOS_POLICY_ID   = 20;
    const QosPolicyId_t LIFESPAN_QOS_POLICY_ID            = 21;
    const QosPolicyId_t DURABILITYSERVICE_QOS_POLICY_ID   = 22;

    // ----------------------------------------------------------------------
    local interface Entity {
    //  ReturnCode_t set_qos(
    //      in EntityQos qos);
    //  ReturnCode_t get_qos(
    //      inout EntityQos qos);
    //  ReturnCode_t set_listener(
    //      in Listener l,
    //      in StatusMask mask);
    //  Listener get_listener();

      ReturnCode_t enable();

      StatusCondition get_statuscondition();

      StatusMask get_status_changes();

      InstanceHandle_t get_instance_handle();
    };

};

module OpenDDS
{
  const string TRANSPORTTYPE_QOS_POLICY_NAME = "TransportType";

  // OpenDDS-specific QosPolicyId_t values start from the maximum
  // QosPolicyId_t (a 32-bit signed integer) and decrement as new
  // OpenDDS-specific values are added.  The goal is to avoid
  // potential conflicts with new OMG defined QosPolicyId_t values.
  const ::DDS::QosPolicyId_t TRANSPORTTYPE_QOS_POLICY_ID = 0x7fffffff;

  // DomainIds used by the implementation will be larger than this constant:
  const ::DDS::DomainId_t MAX_USER_DOMAINID = 0x7fffffff;

  module DCPS
  {
    const DDS::StatusMask ALL_STATUS_MASK = 0xffffffff;
    const DDS::StatusMask NO_STATUS_MASK  = 0x00000000;
    const DDS::StatusMask DEFAULT_STATUS_MASK = ALL_STATUS_MASK;
  };
};

#endif  /* OPENDDS_DCPS_INFRASTRUCTURE_IDL */

---