summaryrefslogtreecommitdiff
path: root/modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl
diff options
context:
space:
mode:
Diffstat (limited to 'modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl')
-rw-r--r--modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl1206
1 files changed, 1206 insertions, 0 deletions
diff --git a/modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl b/modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl
new file mode 100644
index 00000000000..14a695d5c37
--- /dev/null
+++ b/modules/CIAO/connectors/dds4ccm/idl/dds_rtf2_dcps.idl
@@ -0,0 +1,1206 @@
+// $Id$
+
+#ifndef DDS_RFT2_DCPS_IDL
+#define DDS_RFT2_DCPS_IDL
+
+#define DOMAINID_TYPE_NATIVE long
+#define HANDLE_TYPE_NATIVE long
+#define HANDLE_NIL_NATIVE 0
+#define BUILTIN_TOPIC_KEY_TYPE_NATIVE long
+
+#define TheParticipantFactory
+#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
+
+#include "tao/StringSeq.pidl"
+
+module DDS {
+ struct NativeInstanceHandle_t {
+ octet value[16];
+ unsigned long length;
+ };
+ typedef long DomainId_t;
+ typedef NativeInstanceHandle_t InstanceHandle_t;
+ struct BuiltinTopicKey_t {
+ long value[3];
+ };
+
+ typedef sequence<InstanceHandle_t> InstanceHandleSeq;
+
+ typedef long ReturnCode_t;
+ typedef long QosPolicyId_t;
+ typedef sequence<string> StringSeq;
+
+ struct Duration_t {
+ long sec;
+ unsigned long nanosec;
+ };
+
+ struct Time_t {
+ long sec;
+ unsigned long nanosec;
+ };
+
+ // ----------------------------------------------------------------------
+ // Pre-defined values
+ // ----------------------------------------------------------------------
+ //const InstanceHandle_t HANDLE_NIL = 0;
+
+ 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 QosPolicyCount {
+ QosPolicyId_t policy_id;
+ long count;
+ };
+
+ typedef sequence<QosPolicyCount> QosPolicyCountSeq;
+
+ 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
+ // ----------------------------------------------------------------------
+
+ interface Listener;
+ interface Entity;
+ interface TopicDescription;
+ interface Topic;
+ interface ContentFilteredTopic;
+ interface MultiTopic;
+ interface DataWriter;
+ interface DataReader;
+ interface Subscriber;
+ interface Publisher;
+
+ typedef sequence<DataReader> DataReaderSeq;
+
+ interface Listener {};
+
+ interface TopicListener : Listener {
+ void on_inconsistent_topic(in Topic the_topic,
+ in InconsistentTopicStatus status);
+ };
+
+ interface DataWriterListener : Listener {
+ void on_offered_deadline_missed(
+ in DataWriter writer,
+ in OfferedDeadlineMissedStatus status);
+ void on_offered_incompatible_qos(
+ in DataWriter writer,
+ in OfferedIncompatibleQosStatus status);
+ void on_liveliness_lost(
+ in DataWriter writer,
+ in LivelinessLostStatus status);
+ void on_publication_matched(
+ in DataWriter writer,
+ in PublicationMatchedStatus status);
+ };
+
+ interface PublisherListener : DataWriterListener {
+ };
+
+ interface DataReaderListener : Listener {
+ void on_requested_deadline_missed(
+ in DataReader the_reader,
+ in RequestedDeadlineMissedStatus status);
+ void on_requested_incompatible_qos(
+ in DataReader the_reader,
+ in RequestedIncompatibleQosStatus status);
+ void on_sample_rejected(
+ in DataReader the_reader,
+ in SampleRejectedStatus status);
+ void on_liveliness_changed(
+ in DataReader the_reader,
+ in LivelinessChangedStatus status);
+ void on_data_available(
+ in DataReader the_reader);
+ void on_subscription_matched(
+ in DataReader the_reader,
+ in SubscriptionMatchedStatus status);
+ void on_sample_lost(
+ in DataReader the_reader,
+ in SampleLostStatus status);
+ };
+
+ interface SubscriberListener : DataReaderListener {
+ void on_data_on_readers(
+ in Subscriber the_subscriber);
+ };
+
+
+ interface DomainParticipantListener : TopicListener,
+ PublisherListener,
+ SubscriberListener {
+ };
+
+
+ // ----------------------------------------------------------------------
+ // Conditions
+ // ----------------------------------------------------------------------
+
+ interface Condition {
+ boolean get_trigger_value();
+ };
+
+ typedef sequence<Condition> ConditionSeq;
+
+ interface WaitSet {
+ 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);
+ };
+
+ interface GuardCondition : Condition {
+ ReturnCode_t set_trigger_value(
+ in boolean value);
+ };
+
+ interface StatusCondition : Condition {
+ StatusMask get_enabled_statuses();
+ ReturnCode_t set_enabled_statuses(
+ in StatusMask mask);
+ Entity get_entity();
+ };
+
+ // 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;
+
+
+ interface ReadCondition : Condition {
+ SampleStateMask get_sample_state_mask();
+ ViewStateMask get_view_state_mask();
+ InstanceStateMask get_instance_state_mask();
+ DataReader get_datareader();
+ };
+
+ interface QueryCondition : ReadCondition {
+ string get_query_expression();
+ ReturnCode_t get_query_parameters(
+ inout StringSeq query_parameters);
+ ReturnCode_t set_query_parameters(
+ in StringSeq query_parameters);
+ };
+
+ // ----------------------------------------------------------------------
+ // 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 = "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;
+
+ typedef sequence<octet> OctetSeq;
+ struct UserDataQosPolicy {
+ OctetSeq value;
+ };
+
+ struct TopicDataQosPolicy {
+ OctetSeq value;
+ };
+
+ struct GroupDataQosPolicy {
+ OctetSeq value;
+ };
+
+ struct TransportPriorityQosPolicy {
+ long value;
+ };
+
+ struct LifespanQosPolicy {
+ Duration_t duration;
+ };
+
+ enum DurabilityQosPolicyKind {
+ VOLATILE_DURABILITY_QOS,
+ TRANSIENT_LOCAL_DURABILITY_QOS,
+ TRANSIENT_DURABILITY_QOS,
+ PERSISTENT_DURABILITY_QOS
+ };
+ struct DurabilityQosPolicy {
+ DurabilityQosPolicyKind kind;
+ };
+
+ enum PresentationQosPolicyAccessScopeKind {
+ INSTANCE_PRESENTATION_QOS,
+ TOPIC_PRESENTATION_QOS,
+ GROUP_PRESENTATION_QOS
+ };
+ struct PresentationQosPolicy {
+ PresentationQosPolicyAccessScopeKind access_scope;
+ boolean coherent_access;
+ boolean ordered_access;
+ };
+
+ struct DeadlineQosPolicy {
+ Duration_t period;
+ };
+
+ struct LatencyBudgetQosPolicy {
+ Duration_t duration;
+ };
+
+ enum OwnershipQosPolicyKind {
+ SHARED_OWNERSHIP_QOS,
+ EXCLUSIVE_OWNERSHIP_QOS
+ };
+ struct OwnershipQosPolicy {
+ OwnershipQosPolicyKind kind;
+ };
+
+ struct OwnershipStrengthQosPolicy {
+ long value;
+ };
+
+ enum LivelinessQosPolicyKind {
+ AUTOMATIC_LIVELINESS_QOS,
+ MANUAL_BY_PARTICIPANT_LIVELINESS_QOS,
+ MANUAL_BY_TOPIC_LIVELINESS_QOS
+ };
+
+ struct LivelinessQosPolicy {
+ LivelinessQosPolicyKind kind;
+ Duration_t lease_duration;
+ };
+
+ struct TimeBasedFilterQosPolicy {
+ Duration_t minimum_separation;
+ };
+
+ struct PartitionQosPolicy {
+ StringSeq name;
+ };
+
+ 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;
+ };
+
+ enum HistoryQosPolicyKind {
+ KEEP_LAST_HISTORY_QOS,
+ KEEP_ALL_HISTORY_QOS
+ };
+ struct HistoryQosPolicy {
+ HistoryQosPolicyKind kind;
+ long depth;
+ };
+
+ struct ResourceLimitsQosPolicy {
+ long max_samples;
+ long max_instances;
+ long max_samples_per_instance;
+ };
+
+ struct EntityFactoryQosPolicy {
+ boolean autoenable_created_entities;
+ };
+
+ struct WriterDataLifecycleQosPolicy {
+ boolean autodispose_unregistered_instances;
+ };
+
+ struct ReaderDataLifecycleQosPolicy {
+ Duration_t autopurge_nowriter_samples_delay;
+ Duration_t autopurge_disposed_samples_delay;
+ };
+
+ 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 DomainParticipantFactoryQos {
+ EntityFactoryQosPolicy entity_factory;
+ };
+
+ struct DomainParticipantQos {
+ UserDataQosPolicy user_data;
+ EntityFactoryQosPolicy entity_factory;
+ };
+
+ 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 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 PublisherQos {
+ PresentationQosPolicy presentation;
+ PartitionQosPolicy partition;
+ GroupDataQosPolicy group_data;
+ EntityFactoryQosPolicy entity_factory;
+ };
+
+ 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 ParticipantBuiltinTopicData {
+ BuiltinTopicKey_t key;
+ UserDataQosPolicy user_data;
+ };
+
+ 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;
+ };
+
+ 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;
+ };
+
+ 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;
+ };
+
+ // ----------------------------------------------------------------------
+ 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();
+ };
+
+ // ----------------------------------------------------------------------
+ interface DomainParticipant : Entity {
+ // Factory interfaces
+ Publisher create_publisher(
+ in PublisherQos qos,
+ in PublisherListener a_listener,
+ in StatusMask mask);
+ ReturnCode_t delete_publisher(
+ in Publisher p);
+
+ Subscriber create_subscriber(
+ in SubscriberQos qos,
+ in SubscriberListener a_listener,
+ in StatusMask mask);
+ ReturnCode_t delete_subscriber(
+ in Subscriber s);
+ Subscriber get_builtin_subscriber();
+
+ Topic create_topic(
+ in string topic_name,
+ in string type_name,
+ in TopicQos qos,
+ in TopicListener a_listener,
+ in StatusMask mask);
+
+ ReturnCode_t delete_topic(
+ in Topic a_topic);
+
+ Topic find_topic(
+ in string topic_name,
+ in Duration_t timeout);
+ TopicDescription lookup_topicdescription(
+ in string name);
+
+ ContentFilteredTopic create_contentfilteredtopic(
+ in string name,
+ in Topic related_topic,
+ in string filter_expression,
+ in StringSeq expression_parameters);
+
+ ReturnCode_t delete_contentfilteredtopic(
+ in ContentFilteredTopic a_contentfilteredtopic);
+
+ MultiTopic create_multitopic(
+ in string name,
+ in string type_name,
+ in string subscription_expression,
+ in StringSeq expression_parameters);
+
+ ReturnCode_t delete_multitopic(
+ in MultiTopic a_multitopic);
+
+ ReturnCode_t delete_contained_entities();
+
+ ReturnCode_t set_qos(
+ in DomainParticipantQos qos);
+ ReturnCode_t get_qos(
+ inout DomainParticipantQos qos);
+
+ ReturnCode_t set_listener(
+ in DomainParticipantListener a_listener,
+ in StatusMask mask);
+ DomainParticipantListener get_listener();
+
+ ReturnCode_t ignore_participant(
+ in InstanceHandle_t handle);
+ ReturnCode_t ignore_topic(
+ in InstanceHandle_t handle);
+ ReturnCode_t ignore_publication(
+ in InstanceHandle_t handle);
+ ReturnCode_t ignore_subscription(
+ in InstanceHandle_t handle);
+
+ DomainId_t get_domain_id();
+ ReturnCode_t assert_liveliness();
+
+ ReturnCode_t set_default_publisher_qos(
+ in PublisherQos qos);
+ ReturnCode_t get_default_publisher_qos(
+ inout PublisherQos qos);
+
+ ReturnCode_t set_default_subscriber_qos(
+ in SubscriberQos qos);
+ ReturnCode_t get_default_subscriber_qos(
+ inout SubscriberQos qos);
+
+ ReturnCode_t set_default_topic_qos(
+ in TopicQos qos);
+ ReturnCode_t get_default_topic_qos(
+ inout TopicQos qos);
+
+ ReturnCode_t get_discovered_participants(
+ inout InstanceHandleSeq participant_handles);
+ ReturnCode_t get_discovered_participant_data(
+ inout ParticipantBuiltinTopicData participant_data,
+ in InstanceHandle_t participant_handle);
+
+ ReturnCode_t get_discovered_topics(
+ inout InstanceHandleSeq topic_handles);
+ ReturnCode_t get_discovered_topic_data(
+ inout TopicBuiltinTopicData topic_data,
+ in InstanceHandle_t topic_handle);
+
+ boolean contains_entity(
+ in InstanceHandle_t a_handle);
+
+ ReturnCode_t get_current_time(
+ inout Time_t current_time);
+ };
+
+ interface DomainParticipantFactory {
+ DomainParticipant create_participant(
+ in DomainId_t domain_id,
+ in DomainParticipantQos qos,
+ in DomainParticipantListener a_listener,
+ in StatusMask mask);
+ ReturnCode_t delete_participant(
+ in DomainParticipant a_participant);
+
+ DomainParticipant lookup_participant(
+ in DomainId_t domain_id);
+
+ ReturnCode_t set_default_participant_qos(
+ in DomainParticipantQos qos);
+ ReturnCode_t get_default_participant_qos(
+ inout DomainParticipantQos qos);
+
+ ReturnCode_t set_qos(
+ in DomainParticipantFactoryQos qos);
+ ReturnCode_t get_qos(
+ inout DomainParticipantFactoryQos qos);
+ };
+
+ interface TypeSupport {
+ // ReturnCode_t register_type(
+ // in DomainParticipant domain,
+ // in string type_name);
+ // string get_type_name();
+ };
+
+ // ----------------------------------------------------------------------
+ interface TopicDescription {
+ string get_type_name();
+ string get_name();
+
+ DomainParticipant get_participant();
+ };
+
+ interface Topic : Entity, TopicDescription {
+ ReturnCode_t set_qos(
+ in TopicQos qos);
+ ReturnCode_t get_qos(
+ inout TopicQos qos);
+ ReturnCode_t set_listener(
+ in TopicListener a_listener,
+ in StatusMask mask);
+ TopicListener get_listener();
+ // Access the status
+ ReturnCode_t get_inconsistent_topic_status(
+ inout InconsistentTopicStatus a_status);
+ };
+
+ interface ContentFilteredTopic : TopicDescription {
+ string get_filter_expression();
+ ReturnCode_t get_expression_parameters(
+ inout StringSeq expression_parameters);
+ ReturnCode_t set_expression_parameters(
+ in StringSeq expression_parameters);
+ Topic get_related_topic();
+ };
+
+ interface MultiTopic : TopicDescription {
+ string get_subscription_expression();
+ ReturnCode_t get_expression_parameters(
+ inout StringSeq expression_parameters);
+ ReturnCode_t set_expression_parameters(
+ in StringSeq expression_parameters);
+ };
+
+ // ----------------------------------------------------------------------
+ interface Publisher : Entity {
+ DataWriter create_datawriter(
+ in Topic a_topic,
+ in DataWriterQos qos,
+ in DataWriterListener a_listener,
+ in StatusMask mask);
+ ReturnCode_t delete_datawriter(
+ in DataWriter a_datawriter);
+ DataWriter lookup_datawriter(
+ in string topic_name);
+
+ ReturnCode_t delete_contained_entities();
+
+ ReturnCode_t set_qos(
+ in PublisherQos qos);
+ ReturnCode_t get_qos(
+ inout PublisherQos qos);
+
+ ReturnCode_t set_listener(
+ in PublisherListener a_listener,
+ in StatusMask mask);
+ PublisherListener get_listener();
+
+ ReturnCode_t suspend_publications();
+ ReturnCode_t resume_publications();
+
+ ReturnCode_t begin_coherent_changes();
+ ReturnCode_t end_coherent_changes();
+
+ ReturnCode_t wait_for_acknowledgments(
+ in Duration_t max_wait);
+
+ DomainParticipant get_participant();
+
+ ReturnCode_t set_default_datawriter_qos(
+ in DataWriterQos qos);
+ ReturnCode_t get_default_datawriter_qos(
+ inout DataWriterQos qos);
+
+ ReturnCode_t copy_from_topic_qos(
+ inout DataWriterQos a_datawriter_qos,
+ in TopicQos a_topic_qos);
+ };
+
+ interface DataWriter : Entity {
+ // InstanceHandle_t register_instance(
+ // in Data instance_data);
+ // InstanceHandle_t register_instance_w_timestamp(
+ // in Data instance_data,
+ // in Time_t source_timestamp);
+ // ReturnCode_t unregister_instance(
+ // in Data instance_data,
+ // in InstanceHandle_t handle);
+ // ReturnCode_t unregister_instance_w_timestamp(
+ // in Data instance_data,
+ // in InstanceHandle_t handle,
+ // in Time_t source_timestamp);
+ // ReturnCode_t write(
+ // in Data instance_data,
+ // in InstanceHandle_t handle);
+ // ReturnCode_t write_w_timestamp(
+ // in Data instance_data,
+ // in InstanceHandle_t handle,
+ // in Time_t source_timestamp);
+ // ReturnCode_t dispose(
+ // in Data instance_data,
+ // in InstanceHandle_t instance_handle);
+ // ReturnCode_t dispose_w_timestamp(
+ // in Data instance_data,
+ // in InstanceHandle_t instance_handle,
+ // in Time_t source_timestamp);
+ // ReturnCode_t get_key_value(
+ // inout Data key_holder,
+ // in InstanceHandle_t handle);
+ // InstanceHandle_t lookup_instance(
+ // in Data instance_data);
+
+ ReturnCode_t set_qos(
+ in DataWriterQos qos);
+ ReturnCode_t get_qos(
+ inout DataWriterQos qos);
+
+ ReturnCode_t set_listener(
+ in DataWriterListener a_listener,
+ in StatusMask mask);
+ DataWriterListener get_listener();
+
+ Topic get_topic();
+ Publisher get_publisher();
+
+ ReturnCode_t wait_for_acknowledgments(
+ in Duration_t max_wait);
+
+ // Access the status
+ ReturnCode_t get_liveliness_lost_status(
+ inout LivelinessLostStatus status);
+ ReturnCode_t get_offered_deadline_missed_status(
+ inout OfferedDeadlineMissedStatus status);
+ ReturnCode_t get_offered_incompatible_qos_status(
+ inout OfferedIncompatibleQosStatus status);
+ ReturnCode_t get_publication_matched_status(
+ inout PublicationMatchedStatus status);
+
+ ReturnCode_t assert_liveliness();
+
+ ReturnCode_t get_matched_subscriptions(
+ inout InstanceHandleSeq subscription_handles);
+ ReturnCode_t get_matched_subscription_data(
+ inout SubscriptionBuiltinTopicData subscription_data,
+ in InstanceHandle_t subscription_handle);
+ };
+
+ // ----------------------------------------------------------------------
+ interface Subscriber : Entity {
+ DataReader create_datareader(
+ in TopicDescription a_topic,
+ in DataReaderQos qos,
+ in DataReaderListener a_listener,
+ in StatusMask mask);
+ ReturnCode_t delete_datareader(
+ in DataReader a_datareader);
+ ReturnCode_t delete_contained_entities();
+ DataReader lookup_datareader(
+ in string topic_name);
+ ReturnCode_t get_datareaders(
+ inout DataReaderSeq readers,
+ in SampleStateMask sample_states,
+ in ViewStateMask view_states,
+ in InstanceStateMask instance_states);
+ ReturnCode_t notify_datareaders();
+
+ ReturnCode_t set_qos(
+ in SubscriberQos qos);
+ ReturnCode_t get_qos(
+ inout SubscriberQos qos);
+
+ ReturnCode_t set_listener(
+ in SubscriberListener a_listener,
+ in StatusMask mask);
+ SubscriberListener get_listener();
+
+ ReturnCode_t begin_access();
+ ReturnCode_t end_access();
+
+ DomainParticipant get_participant();
+
+ ReturnCode_t set_default_datareader_qos(
+ in DataReaderQos qos);
+ ReturnCode_t get_default_datareader_qos(
+ inout DataReaderQos qos);
+
+ ReturnCode_t copy_from_topic_qos(
+ inout DataReaderQos a_datareader_qos,
+ in TopicQos a_topic_qos);
+ };
+
+ interface DataReader : Entity {
+ // ReturnCode_t read(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t take(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t read_w_condition(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in ReadCondition a_condition);
+
+ // ReturnCode_t take_w_condition(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in ReadCondition a_condition);
+
+ // ReturnCode_t read_next_sample(
+ // inout Data data_values,
+ // inout SampleInfo sample_info);
+
+ // ReturnCode_t take_next_sample(
+ // inout Data data_values,
+ // inout SampleInfo sample_info);
+
+ // ReturnCode_t read_instance(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t a_handle,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t take_instance(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t a_handle,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t read_next_instance(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t previous_handle,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t take_next_instance(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t previous_handle,
+ // in SampleStateMask sample_states,
+ // in ViewStateMask view_states,
+ // in InstanceStateMask instance_states);
+
+ // ReturnCode_t read_next_instance_w_condition(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t previous_handle,
+ // in ReadCondition a_condition);
+
+ // ReturnCode_t take_next_instance_w_condition(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos,
+ // in long max_samples,
+ // in InstanceHandle_t previous_handle,
+ // in ReadCondition a_condition);
+
+ // ReturnCode_t return_loan(
+ // inout DataSeq data_values,
+ // inout SampleInfoSeq sample_infos);
+
+ // ReturnCode_t get_key_value(
+ // inout Data key_holder,
+ // in InstanceHandle_t handle);
+
+ // InstanceHandle_t lookup_instance(
+ // in Data instance_data);
+
+ ReadCondition create_readcondition(
+ in SampleStateMask sample_states,
+ in ViewStateMask view_states,
+ in InstanceStateMask instance_states);
+
+ QueryCondition create_querycondition(
+ in SampleStateMask sample_states,
+ in ViewStateMask view_states,
+ in InstanceStateMask instance_states,
+ in string query_expression,
+ in StringSeq query_parameters);
+
+ ReturnCode_t delete_readcondition(
+ in ReadCondition a_condition);
+
+ ReturnCode_t delete_contained_entities();
+
+ ReturnCode_t set_qos(
+ in DataReaderQos qos);
+ ReturnCode_t get_qos(
+ inout DataReaderQos qos);
+
+ ReturnCode_t set_listener(
+ in DataReaderListener a_listener,
+ in StatusMask mask);
+ DataReaderListener get_listener();
+
+ TopicDescription get_topicdescription();
+ Subscriber get_subscriber();
+
+ ReturnCode_t get_sample_rejected_status(
+ inout SampleRejectedStatus status);
+ ReturnCode_t get_liveliness_changed_status(
+ inout LivelinessChangedStatus status);
+ ReturnCode_t get_requested_deadline_missed_status(
+ inout RequestedDeadlineMissedStatus status);
+ ReturnCode_t get_requested_incompatible_qos_status(
+ inout RequestedIncompatibleQosStatus status);
+ ReturnCode_t get_subscription_matched_status(
+ inout SubscriptionMatchedStatus status);
+ ReturnCode_t get_sample_lost_status(
+ inout SampleLostStatus status);
+
+ ReturnCode_t wait_for_historical_data(
+ in Duration_t max_wait);
+
+ ReturnCode_t get_matched_publications(
+ inout InstanceHandleSeq publication_handles);
+ ReturnCode_t get_matched_publication_data(
+ inout PublicationBuiltinTopicData publication_data,
+ in InstanceHandle_t publication_handle);
+ };
+
+
+ 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;
+ };
+
+ typedef sequence<SampleInfo> SampleInfoSeq;
+};
+
+#endif
View Lorry Controller Status