performance-tests/bench/builder_idl/Builder.idl

   1 #include <tao/DoubleSeq.pidl>
   2 #include <tao/StringSeq.pidl>
   3 #include "dds/DdsDcpsCore.idl"
   4
   5 module Builder {
   6
   7 // ---
   8 // Common Section
   9 // ---
  10
  11   // A common definition for timestamps
  12   struct TimeStamp {
  13     long sec;
  14     unsigned long nsec;
  15   };
  16
  17   typedef sequence<TimeStamp> TimeStampSeq;
  18
  19   typedef sequence<string> StringSeq;
  20   typedef sequence<StringSeq> StringSeqSeq;
  21
  22   typedef sequence<double> DoubleSeq;
  23
  24   enum PropertyValueKind { PVK_TIME, PVK_TIME_SEQ, PVK_STRING, PVK_STRING_SEQ, PVK_STRING_SEQ_SEQ, PVK_DOUBLE, PVK_DOUBLE_SEQ, PVK_ULL };
  25   union PropertyValue switch (PropertyValueKind) {
  26     case PVK_TIME:
  27       TimeStamp time_prop;
  28     case PVK_TIME_SEQ:
  29       TimeStampSeq time_seq_prop;
  30     case PVK_STRING:
  31       string string_prop;
  32     case PVK_STRING_SEQ:
  33       StringSeq string_seq_prop;
  34     case PVK_STRING_SEQ_SEQ:
  35       StringSeqSeq string_seq_seq_prop;
  36     case PVK_DOUBLE:
  37       double double_prop;
  38     case PVK_DOUBLE_SEQ:
  39        DoubleSeq double_seq_prop;
  40     case PVK_ULL:
  41       unsigned long long ull_prop;
  42   };
  43
  44   struct Property {
  45     string name;
  46     PropertyValue value;
  47   };
  48
  49   typedef sequence<Property> PropertySeq;
  50
  51 // ---
  52 // QoS Library Section
  53 // ---
  54
  55   struct TopicFilteredDataWriterQos {
  56     string filter_expression;
  57     DDS::DataWriterQos qos;
  58   };
  59
  60   typedef sequence<TopicFilteredDataWriterQos> TopicFilteredDataWriterQosSeq;
  61
  62   struct TopicFilteredDataReaderQos {
  63     string filter_expression;
  64     DDS::DataReaderQos qos;
  65   };
  66
  67   typedef sequence<TopicFilteredDataReaderQos> TopicFilteredDataReaderQosSeq;
  68
  69   struct QosProfiles {
  70     string name;
  71     string base_name;
  72     DDS::DataWriterQos datawriter_qos;
  73     DDS::DataReaderQos datareader_qos;
  74     TopicFilteredDataWriterQosSeq topic_filtered_datawriter_qos;
  75     TopicFilteredDataReaderQosSeq topic_filtered_datareader_qos;
  76   };
  77
  78   struct QosLibrary {
  79     string name;
  80     QosProfiles qos_profiles;
  81     DDS::DataWriterQos datawriter_qos; // shorthand for a single profile with a single qos
  82     DDS::DataReaderQos datareader_qos; // shorthand for a single profile with a single qos
  83   };
  84
  85 // ---
  86 // QoS Mask Section
  87 // ---
  88
  89   struct PropertyQosPolicyMask {
  90               boolean has_value;
  91               boolean has_binary_value;
  92               };
  93
  94   struct UserDataQosPolicyMask {
  95               boolean has_value;
  96               };
  97
  98   struct GroupDataQosPolicyMask {
  99               boolean has_value;
 100               };
 101
 102   struct TopicDataQosPolicyMask {
 103               boolean has_value;
 104               };
 105
 106   struct PartitionQosPolicyMask {
 107               boolean has_name;
 108               };
 109
 110   struct DurabilityQosPolicyMask {
 111               boolean has_kind;
 112               };
 113
 114   struct DurabilityServiceQosPolicyMask {
 115               boolean has_service_cleanup_delay;
 116               boolean has_history_kind;
 117               boolean has_history_depth;
 118               boolean has_max_samples;
 119               boolean has_max_instances;
 120               boolean has_max_samples_per_instance;
 121               };
 122
 123   struct DeadlineQosPolicyMask {
 124               boolean has_period;
 125               };
 126
 127   struct LatencyBudgetQosPolicyMask {
 128               boolean has_duration;
 129               };
 130
 131   struct LivelinessQosPolicyMask {
 132               boolean has_kind;
 133               boolean has_lease_duration;
 134               };
 135
 136   struct ReliabilityQosPolicyMask {
 137               boolean has_kind;
 138               boolean has_max_blocking_time;
 139               };
 140
 141   struct DestinationOrderQosPolicyMask {
 142               boolean has_kind;
 143               };
 144
 145   struct HistoryQosPolicyMask {
 146               boolean has_kind;
 147               boolean has_depth;
 148               };
 149
 150   struct ResourceLimitsQosPolicyMask {
 151               boolean has_max_samples;
 152               boolean has_max_instances;
 153               boolean has_max_samples_per_instance;
 154               };
 155
 156   struct TransportPriorityQosPolicyMask {
 157               boolean has_value;
 158               };
 159
 160   struct LifespanQosPolicyMask {
 161               boolean has_duration;
 162               };
 163
 164   struct OwnershipQosPolicyMask {
 165               boolean has_kind;
 166               };
 167
 168   struct OwnershipStrengthQosPolicyMask {
 169               boolean has_value;
 170               };
 171
 172   struct PresentationQosPolicyMask {
 173               boolean has_access_scope;
 174               boolean has_coherent_access;
 175               boolean has_ordered_access;
 176               };
 177
 178   struct TimeBasedFilterQosPolicyMask {
 179               boolean has_minimum_separation;
 180               };
 181
 182   struct TopicQosMask {
 183               TopicDataQosPolicyMask topic_data;
 184               DurabilityQosPolicyMask durability;
 185               DurabilityServiceQosPolicyMask durability_service;
 186               DeadlineQosPolicyMask deadline;
 187               LatencyBudgetQosPolicyMask latency_budget;
 188               LivelinessQosPolicyMask liveliness;
 189               ReliabilityQosPolicyMask reliability;
 190               DestinationOrderQosPolicyMask destination_order;
 191               HistoryQosPolicyMask history;
 192               ResourceLimitsQosPolicyMask resource_limits;
 193               TransportPriorityQosPolicyMask transport_priority;
 194               LifespanQosPolicyMask lifespan;
 195               OwnershipQosPolicyMask ownership;
 196               };
 197
 198   struct WriterDataLifecycleQosPolicyMask {
 199               boolean has_autodispose_unregistered_instances;
 200               };
 201
 202   struct DataWriterQosMask {
 203               DurabilityQosPolicyMask durability;
 204               DurabilityServiceQosPolicyMask durability_service;
 205               DeadlineQosPolicyMask deadline;
 206               LatencyBudgetQosPolicyMask latency_budget;
 207               LivelinessQosPolicyMask liveliness;
 208               ReliabilityQosPolicyMask reliability;
 209               DestinationOrderQosPolicyMask destination_order;
 210               HistoryQosPolicyMask history;
 211               ResourceLimitsQosPolicyMask resource_limits;
 212               TransportPriorityQosPolicyMask transport_priority;
 213               LifespanQosPolicyMask lifespan;
 214               UserDataQosPolicyMask user_data;
 215               OwnershipQosPolicyMask ownership;
 216               OwnershipStrengthQosPolicyMask ownership_strength;
 217               WriterDataLifecycleQosPolicyMask writer_data_lifecycle;
 218               };
 219
 220   struct EntityFactoryQosPolicyMask {
 221               boolean has_autoenable_created_entities;
 222               };
 223
 224   struct PublisherQosMask {
 225               PresentationQosPolicyMask presentation;
 226               PartitionQosPolicyMask partition;
 227               GroupDataQosPolicyMask group_data;
 228               EntityFactoryQosPolicyMask entity_factory;
 229               };
 230
 231   struct ReaderDataLifecycleQosPolicyMask {
 232               boolean has_autopurge_nowriter_samples_delay;
 233               boolean has_autopurge_disposed_samples_delay;
 234               };
 235
 236   struct DataReaderQosMask {
 237               DurabilityQosPolicyMask durability;
 238               DeadlineQosPolicyMask deadline;
 239               LatencyBudgetQosPolicyMask latency_budget;
 240               LivelinessQosPolicyMask liveliness;
 241               ReliabilityQosPolicyMask reliability;
 242               DestinationOrderQosPolicyMask destination_order;
 243               HistoryQosPolicyMask history;
 244               ResourceLimitsQosPolicyMask resource_limits;
 245               UserDataQosPolicyMask user_data;
 246               OwnershipQosPolicyMask ownership;
 247               TimeBasedFilterQosPolicyMask time_based_filter;
 248               ReaderDataLifecycleQosPolicyMask reader_data_lifecycle;
 249               };
 250
 251   struct SubscriberQosMask {
 252               PresentationQosPolicyMask presentation;
 253               PartitionQosPolicyMask partition;
 254               GroupDataQosPolicyMask group_data;
 255               EntityFactoryQosPolicyMask entity_factory;
 256               };
 257
 258   struct DomainParticipantFactoryQosMask {
 259               EntityFactoryQosPolicyMask entity_factory;
 260               };
 261
 262   struct DomainParticipantQosMask {
 263               UserDataQosPolicyMask user_data;
 264               EntityFactoryQosPolicyMask entity_factory;
 265               PropertyQosPolicyMask property;
 266               };
 267
 268 // ---
 269 // Configuration Section
 270 // ---
 271
 272   // ConfigProperty
 273
 274   struct ConfigProperty {
 275     string name;
 276     string value;
 277   };
 278
 279   typedef sequence<ConfigProperty> ConfigPropertySeq;
 280
 281   // ConfigSection
 282
 283   struct ConfigSection {
 284     string name;
 285     ConfigPropertySeq properties;
 286   };
 287
 288   typedef sequence<ConfigSection> ConfigSectionSeq;
 289
 290   // Writer
 291
 292   struct DataWriterConfig {
 293     string name;
 294     string topic_name;
 295     string listener_type_name;
 296     unsigned long listener_status_mask;
 297     PropertySeq listener_properties;
 298     string transport_config_name;
 299     DDS::DataWriterQos qos;
 300     DataWriterQosMask qos_mask;
 301     StringSeq tags;
 302   };
 303
 304   typedef sequence<DataWriterConfig> DataWriterConfigSeq;
 305
 306   // Reader
 307
 308   struct DataReaderConfig {
 309     string name;
 310     string topic_name;
 311     string listener_type_name;
 312     unsigned long listener_status_mask;
 313     PropertySeq listener_properties;
 314     string transport_config_name;
 315     DDS::DataReaderQos qos;
 316     DataReaderQosMask qos_mask;
 317     StringSeq tags;
 318   };
 319
 320   typedef sequence<DataReaderConfig> DataReaderConfigSeq;
 321
 322   // Publisher
 323
 324   struct PublisherConfig {
 325     string name;
 326     string listener_type_name;
 327     unsigned long listener_status_mask;
 328     PropertySeq listener_properties;
 329     string transport_config_name;
 330     DDS::PublisherQos qos;
 331     PublisherQosMask qos_mask;
 332     DataWriterConfigSeq datawriters;
 333   };
 334
 335   typedef sequence<PublisherConfig> PublisherConfigSeq;
 336
 337   // Subscription
 338
 339   struct SubscriberConfig {
 340     string name;
 341     string listener_type_name;
 342     unsigned long listener_status_mask;
 343     PropertySeq listener_properties;
 344     string transport_config_name;
 345     DDS::SubscriberQos qos;
 346     SubscriberQosMask qos_mask;
 347     DataReaderConfigSeq datareaders;
 348   };
 349
 350   typedef sequence<SubscriberConfig> SubscriberConfigSeq;
 351
 352   // Topic
 353
 354   struct ContentFilteredTopic {
 355     string cft_name;
 356     string cft_expression;
 357     DDS::StringSeq cft_parameters;
 358   };
 359
 360   typedef sequence<ContentFilteredTopic> ContentFilteredTopicSeq;
 361
 362   struct TopicConfig {
 363     string name;
 364     string type_name;
 365     DDS::TopicQos qos;
 366     TopicQosMask qos_mask;
 367     string listener_type_name;
 368     unsigned long listener_status_mask;
 369     PropertySeq listener_properties;
 370     string transport_config_name;
 371     ContentFilteredTopicSeq content_filtered_topics;
 372   };
 373
 374   typedef sequence<TopicConfig> TopicConfigSeq;
 375
 376   // Participant
 377
 378   struct ParticipantConfig {
 379     string name;
 380     unsigned short domain;
 381     DDS::DomainParticipantQos qos;
 382     DomainParticipantQosMask qos_mask;
 383     string listener_type_name;
 384     unsigned long listener_status_mask;
 385     PropertySeq listener_properties;
 386     string transport_config_name;
 387     StringSeq type_names;
 388     TopicConfigSeq topics;
 389     PublisherConfigSeq publishers;
 390     SubscriberConfigSeq subscribers;
 391   };
 392
 393   typedef sequence<ParticipantConfig> ParticipantConfigSeq;
 394
 395   // Process
 396
 397   @topic
 398   struct ProcessConfig {
 399     string name;
 400     ConfigSectionSeq config_sections;
 401     ParticipantConfigSeq participants;
 402   };
 403
 404 // ---
 405 // Report Section
 406 // ---
 407
 408   struct DataReaderReport {
 409     PropertySeq properties;
 410     StringSeq tags;
 411   };
 412
 413   typedef sequence<DataReaderReport> DataReaderReportSeq;
 414
 415   struct DataWriterReport {
 416     PropertySeq properties;
 417     StringSeq tags;
 418   };
 419
 420   typedef sequence<DataWriterReport> DataWriterReportSeq;
 421
 422   struct SubscriberReport {
 423     DataReaderReportSeq datareaders;
 424   };
 425
 426   typedef sequence<SubscriberReport> SubscriberReportSeq;
 427
 428   struct PublisherReport {
 429     DataWriterReportSeq datawriters;
 430   };
 431
 432   typedef sequence<PublisherReport> PublisherReportSeq;
 433
 434   struct ParticipantReport {
 435     SubscriberReportSeq subscribers;
 436     PublisherReportSeq publishers;
 437   };
 438
 439   typedef sequence<ParticipantReport> ParticipantReportSeq;
 440
 441   struct ProcessReport {
 442     ParticipantReportSeq participants;
 443   };
 444
 445 };