CoreDX DDS C++ Reference Manual
dds_builtin.hh
1 /********************************************
2  * DDS type specific header file. *
3  * Autogenerated by CoreDX DDL compiler. *
4  * Do no edit - edits may be overwritten. *
5  ********************************************/
6 
7 #ifndef _DDS_BUILTIN_HH
8 #define _DDS_BUILTIN_HH
9 #include <string.h>
10 #include <dds/dds.hh>
11 #define DDS_SAFE_UNMARSH 1
12 #include <dds/dds_marsh.h>
13 #ifdef _MSC_VER
14 # pragma warning(push)
15 # pragma warning(disable:4251)
16 # pragma warning(disable:4996)
17 #endif
18 
19 # define DDS_BUILTIN_DDL_VERSION_MAJOR 4
20 # define DDS_BUILTIN_DDL_VERSION_MINOR 0
21 # define DDS_BUILTIN_DDL_VERSION_PATCH 10
22 # define DDS_BUILTIN_DDL_VERSION_MAJOR_STR "4"
23 # define DDS_BUILTIN_DDL_VERSION_MINOR_STR "0"
24 # define DDS_BUILTIN_DDL_VERSION_PATCH_STR "10"
25 
26 #include <dds/dds_builtin_basic.hh>
29  namespace DDS {
30 
31  struct Duration_t;
32  class Duration_tTypeSupport;
33  class Duration_tDataReader;
34  class Duration_tDataWriter;
35 
36 /* DDS Data Type SEQUENCE: sequence<DDS::Duration_t *> */
37 #ifndef _DDS_sequence_cpp_DDS_Duration_tPtr_defined
38 #define _DDS_sequence_cpp_DDS_Duration_tPtr_defined
39  DECLARE_CPP_UNBOUNDED_SEQ( DDS::Duration_t * , Duration_tPtrSeq );
40 #endif /* DDS Data Type SEQUENCE: sequence<Duration_tPtrSeq *> */
41 
45  struct COREDX_CPP_CLASS_API Duration_t {
46  public:
48  Duration_t();
49  ~Duration_t();
50  Duration_t( const Duration_t & other );
51  Duration_t& operator=( const Duration_t & other);
52 
53  void init();
54  void clear();
55  void copy( const DDS::Duration_t * instance );
56 
57  int get_marshal_size(int offset, int just_keys) const ;
58  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
59  unsigned char swap, int just_keys) const ;
60  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
61  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
62  unsigned char swap, int just_keys);
63  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
64 
65  /* Member vars*/
66  int sec;
67  uint32_t nanosec;
68 
69  typedef Duration_tTypeSupport TypeSupport;
70  typedef Duration_tDataReader DataReader;
71  typedef Duration_tDataWriter DataWriter;
72  typedef Duration_tPtrSeq Seq;
73 
74  private:
75 
76  public:
77  Duration_t( int32_t s, uint32_t nsec ) : sec(s), nanosec(nsec) {}
78  operator DDS_Duration_t () { DDS_Duration_t retval; retval.sec = sec; retval.nanosec=nanosec; return retval; }
79 
80  }; //DDS::Duration_t
81 
82  struct UserDataQosPolicy;
83  class UserDataQosPolicyTypeSupport;
84  class UserDataQosPolicyDataReader;
85  class UserDataQosPolicyDataWriter;
86 
87 /* DDS Data Type SEQUENCE: sequence<DDS::UserDataQosPolicy *> */
88 #ifndef _DDS_sequence_cpp_DDS_UserDataQosPolicyPtr_defined
89 #define _DDS_sequence_cpp_DDS_UserDataQosPolicyPtr_defined
90  DECLARE_CPP_UNBOUNDED_SEQ( DDS::UserDataQosPolicy * , UserDataQosPolicyPtrSeq );
91 #endif /* DDS Data Type SEQUENCE: sequence<UserDataQosPolicyPtrSeq *> */
92 
106  struct COREDX_CPP_CLASS_API UserDataQosPolicy {
107  public:
109  UserDataQosPolicy();
110  ~UserDataQosPolicy();
111  UserDataQosPolicy( const UserDataQosPolicy & other );
112  UserDataQosPolicy& operator=( const UserDataQosPolicy & other);
113 
114  void init();
115  void clear();
116  void copy( const DDS::UserDataQosPolicy * instance );
117 
118  int get_marshal_size(int offset, int just_keys) const ;
119  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
120  unsigned char swap, int just_keys) const ;
121  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
122  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
123  unsigned char swap, int just_keys);
124  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
125 
126  /* Member vars*/
128  DDS::OctetSeq value;
129 
130  typedef UserDataQosPolicyTypeSupport TypeSupport;
131  typedef UserDataQosPolicyDataReader DataReader;
132  typedef UserDataQosPolicyDataWriter DataWriter;
133  typedef UserDataQosPolicyPtrSeq Seq;
134 
135  private:
136 
137  }; //DDS::UserDataQosPolicy
138 
139  struct TopicDataQosPolicy;
140  class TopicDataQosPolicyTypeSupport;
141  class TopicDataQosPolicyDataReader;
142  class TopicDataQosPolicyDataWriter;
143 
144 /* DDS Data Type SEQUENCE: sequence<DDS::TopicDataQosPolicy *> */
145 #ifndef _DDS_sequence_cpp_DDS_TopicDataQosPolicyPtr_defined
146 #define _DDS_sequence_cpp_DDS_TopicDataQosPolicyPtr_defined
147  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TopicDataQosPolicy * , TopicDataQosPolicyPtrSeq );
148 #endif /* DDS Data Type SEQUENCE: sequence<TopicDataQosPolicyPtrSeq *> */
149 
163  struct COREDX_CPP_CLASS_API TopicDataQosPolicy {
164  public:
166  TopicDataQosPolicy();
167  ~TopicDataQosPolicy();
168  TopicDataQosPolicy( const TopicDataQosPolicy & other );
169  TopicDataQosPolicy& operator=( const TopicDataQosPolicy & other);
170 
171  void init();
172  void clear();
173  void copy( const DDS::TopicDataQosPolicy * instance );
174 
175  int get_marshal_size(int offset, int just_keys) const ;
176  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
177  unsigned char swap, int just_keys) const ;
178  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
179  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
180  unsigned char swap, int just_keys);
181  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
182 
183  /* Member vars*/
185  DDS::OctetSeq value;
186 
187  typedef TopicDataQosPolicyTypeSupport TypeSupport;
188  typedef TopicDataQosPolicyDataReader DataReader;
189  typedef TopicDataQosPolicyDataWriter DataWriter;
190  typedef TopicDataQosPolicyPtrSeq Seq;
191 
192  private:
193 
194  }; //DDS::TopicDataQosPolicy
195 
196  struct GroupDataQosPolicy;
197  class GroupDataQosPolicyTypeSupport;
198  class GroupDataQosPolicyDataReader;
199  class GroupDataQosPolicyDataWriter;
200 
201 /* DDS Data Type SEQUENCE: sequence<DDS::GroupDataQosPolicy *> */
202 #ifndef _DDS_sequence_cpp_DDS_GroupDataQosPolicyPtr_defined
203 #define _DDS_sequence_cpp_DDS_GroupDataQosPolicyPtr_defined
204  DECLARE_CPP_UNBOUNDED_SEQ( DDS::GroupDataQosPolicy * , GroupDataQosPolicyPtrSeq );
205 #endif /* DDS Data Type SEQUENCE: sequence<GroupDataQosPolicyPtrSeq *> */
206 
221  struct COREDX_CPP_CLASS_API GroupDataQosPolicy {
222  public:
224  GroupDataQosPolicy();
225  ~GroupDataQosPolicy();
226  GroupDataQosPolicy( const GroupDataQosPolicy & other );
227  GroupDataQosPolicy& operator=( const GroupDataQosPolicy & other);
228 
229  void init();
230  void clear();
231  void copy( const DDS::GroupDataQosPolicy * instance );
232 
233  int get_marshal_size(int offset, int just_keys) const ;
234  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
235  unsigned char swap, int just_keys) const ;
236  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
237  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
238  unsigned char swap, int just_keys);
239  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
240 
241  /* Member vars*/
243  DDS::OctetSeq value;
244 
245  typedef GroupDataQosPolicyTypeSupport TypeSupport;
246  typedef GroupDataQosPolicyDataReader DataReader;
247  typedef GroupDataQosPolicyDataWriter DataWriter;
248  typedef GroupDataQosPolicyPtrSeq Seq;
249 
250  private:
251 
252  }; //DDS::GroupDataQosPolicy
253 
254  struct TransportPriorityQosPolicy;
255  class TransportPriorityQosPolicyTypeSupport;
256  class TransportPriorityQosPolicyDataReader;
257  class TransportPriorityQosPolicyDataWriter;
258 
259 /* DDS Data Type SEQUENCE: sequence<DDS::TransportPriorityQosPolicy *> */
260 #ifndef _DDS_sequence_cpp_DDS_TransportPriorityQosPolicyPtr_defined
261 #define _DDS_sequence_cpp_DDS_TransportPriorityQosPolicyPtr_defined
262  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TransportPriorityQosPolicy * , TransportPriorityQosPolicyPtrSeq );
263 #endif /* DDS Data Type SEQUENCE: sequence<TransportPriorityQosPolicyPtrSeq *> */
264 
269  struct COREDX_CPP_CLASS_API TransportPriorityQosPolicy {
270  public:
272  TransportPriorityQosPolicy();
273  ~TransportPriorityQosPolicy();
274  TransportPriorityQosPolicy( const TransportPriorityQosPolicy & other );
275  TransportPriorityQosPolicy& operator=( const TransportPriorityQosPolicy & other);
276 
277  void init();
278  void clear();
279  void copy( const DDS::TransportPriorityQosPolicy * instance );
280 
281  int get_marshal_size(int offset, int just_keys) const ;
282  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
283  unsigned char swap, int just_keys) const ;
284  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
285  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
286  unsigned char swap, int just_keys);
287  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
288 
289  /* Member vars*/
291  int value;
292 
293  typedef TransportPriorityQosPolicyTypeSupport TypeSupport;
294  typedef TransportPriorityQosPolicyDataReader DataReader;
295  typedef TransportPriorityQosPolicyDataWriter DataWriter;
296  typedef TransportPriorityQosPolicyPtrSeq Seq;
297 
298  private:
299 
300  }; //DDS::TransportPriorityQosPolicy
301 
302  struct LifespanQosPolicy;
303  class LifespanQosPolicyTypeSupport;
304  class LifespanQosPolicyDataReader;
305  class LifespanQosPolicyDataWriter;
306 
307 /* DDS Data Type SEQUENCE: sequence<DDS::LifespanQosPolicy *> */
308 #ifndef _DDS_sequence_cpp_DDS_LifespanQosPolicyPtr_defined
309 #define _DDS_sequence_cpp_DDS_LifespanQosPolicyPtr_defined
310  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LifespanQosPolicy * , LifespanQosPolicyPtrSeq );
311 #endif /* DDS Data Type SEQUENCE: sequence<LifespanQosPolicyPtrSeq *> */
312 
320  struct COREDX_CPP_CLASS_API LifespanQosPolicy {
321  public:
323  LifespanQosPolicy();
324  ~LifespanQosPolicy();
325  LifespanQosPolicy( const LifespanQosPolicy & other );
326  LifespanQosPolicy& operator=( const LifespanQosPolicy & other);
327 
328  void init();
329  void clear();
330  void copy( const DDS::LifespanQosPolicy * instance );
331 
332  int get_marshal_size(int offset, int just_keys) const ;
333  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
334  unsigned char swap, int just_keys) const ;
335  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
336  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
337  unsigned char swap, int just_keys);
338  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
339 
340  /* Member vars*/
342  struct DDS::Duration_t duration;
343 
344  typedef LifespanQosPolicyTypeSupport TypeSupport;
345  typedef LifespanQosPolicyDataReader DataReader;
346  typedef LifespanQosPolicyDataWriter DataWriter;
347  typedef LifespanQosPolicyPtrSeq Seq;
348 
349  private:
350 
351  }; //DDS::LifespanQosPolicy
352 
353 
357  enum DurabilityQosPolicyKind { //unsigned int
359  VOLATILE_DURABILITY_QOS = 0,
361  TRANSIENT_LOCAL_DURABILITY_QOS = 1,
363  TRANSIENT_DURABILITY_QOS = 2,
365  PERSISTENT_DURABILITY_QOS = 3
366  };
367 
368  struct DurabilityQosPolicy;
369  class DurabilityQosPolicyTypeSupport;
370  class DurabilityQosPolicyDataReader;
371  class DurabilityQosPolicyDataWriter;
372 
373 /* DDS Data Type SEQUENCE: sequence<DDS::DurabilityQosPolicy *> */
374 #ifndef _DDS_sequence_cpp_DDS_DurabilityQosPolicyPtr_defined
375 #define _DDS_sequence_cpp_DDS_DurabilityQosPolicyPtr_defined
376  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DurabilityQosPolicy * , DurabilityQosPolicyPtrSeq );
377 #endif /* DDS Data Type SEQUENCE: sequence<DurabilityQosPolicyPtrSeq *> */
378 
405  struct COREDX_CPP_CLASS_API DurabilityQosPolicy {
406  public:
408  DurabilityQosPolicy();
409  ~DurabilityQosPolicy();
410  DurabilityQosPolicy( const DurabilityQosPolicy & other );
411  DurabilityQosPolicy& operator=( const DurabilityQosPolicy & other);
412 
413  void init();
414  void clear();
415  void copy( const DDS::DurabilityQosPolicy * instance );
416 
417  int get_marshal_size(int offset, int just_keys) const ;
418  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
419  unsigned char swap, int just_keys) const ;
420  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
421  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
422  unsigned char swap, int just_keys);
423  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
424 
425  /* Member vars*/
427  enum DDS::DurabilityQosPolicyKind kind;
428 
429  typedef DurabilityQosPolicyTypeSupport TypeSupport;
430  typedef DurabilityQosPolicyDataReader DataReader;
431  typedef DurabilityQosPolicyDataWriter DataWriter;
432  typedef DurabilityQosPolicyPtrSeq Seq;
433 
434  private:
435 
436  }; //DDS::DurabilityQosPolicy
437 
438 
442  enum PresentationQosPolicyAccessScopeKind { //unsigned int
444  INSTANCE_PRESENTATION_QOS = 0,
446  TOPIC_PRESENTATION_QOS = 1,
448  GROUP_PRESENTATION_QOS = 2
449  };
450 
451  struct PresentationQosPolicy;
452  class PresentationQosPolicyTypeSupport;
453  class PresentationQosPolicyDataReader;
454  class PresentationQosPolicyDataWriter;
455 
456 /* DDS Data Type SEQUENCE: sequence<DDS::PresentationQosPolicy *> */
457 #ifndef _DDS_sequence_cpp_DDS_PresentationQosPolicyPtr_defined
458 #define _DDS_sequence_cpp_DDS_PresentationQosPolicyPtr_defined
459  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PresentationQosPolicy * , PresentationQosPolicyPtrSeq );
460 #endif /* DDS Data Type SEQUENCE: sequence<PresentationQosPolicyPtrSeq *> */
461 
467  struct COREDX_CPP_CLASS_API PresentationQosPolicy {
468  public:
470  PresentationQosPolicy();
471  ~PresentationQosPolicy();
472  PresentationQosPolicy( const PresentationQosPolicy & other );
473  PresentationQosPolicy& operator=( const PresentationQosPolicy & other);
474 
475  void init();
476  void clear();
477  void copy( const DDS::PresentationQosPolicy * instance );
478 
479  int get_marshal_size(int offset, int just_keys) const ;
480  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
481  unsigned char swap, int just_keys) const ;
482  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
483  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
484  unsigned char swap, int just_keys);
485  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
486 
487  /* Member vars*/
490  enum DDS::PresentationQosPolicyAccessScopeKind access_scope;
492  unsigned char coherent_access;
494  unsigned char ordered_access;
495 
496  typedef PresentationQosPolicyTypeSupport TypeSupport;
497  typedef PresentationQosPolicyDataReader DataReader;
498  typedef PresentationQosPolicyDataWriter DataWriter;
499  typedef PresentationQosPolicyPtrSeq Seq;
500 
501  private:
502 
503  }; //DDS::PresentationQosPolicy
504 
505  struct DeadlineQosPolicy;
506  class DeadlineQosPolicyTypeSupport;
507  class DeadlineQosPolicyDataReader;
508  class DeadlineQosPolicyDataWriter;
509 
510 /* DDS Data Type SEQUENCE: sequence<DDS::DeadlineQosPolicy *> */
511 #ifndef _DDS_sequence_cpp_DDS_DeadlineQosPolicyPtr_defined
512 #define _DDS_sequence_cpp_DDS_DeadlineQosPolicyPtr_defined
513  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DeadlineQosPolicy * , DeadlineQosPolicyPtrSeq );
514 #endif /* DDS Data Type SEQUENCE: sequence<DeadlineQosPolicyPtrSeq *> */
515 
535  struct COREDX_CPP_CLASS_API DeadlineQosPolicy {
536  public:
538  DeadlineQosPolicy();
539  ~DeadlineQosPolicy();
540  DeadlineQosPolicy( const DeadlineQosPolicy & other );
541  DeadlineQosPolicy& operator=( const DeadlineQosPolicy & other);
542 
543  void init();
544  void clear();
545  void copy( const DDS::DeadlineQosPolicy * instance );
546 
547  int get_marshal_size(int offset, int just_keys) const ;
548  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
549  unsigned char swap, int just_keys) const ;
550  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
551  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
552  unsigned char swap, int just_keys);
553  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
554 
555  /* Member vars*/
557  struct DDS::Duration_t period;
558 
559  typedef DeadlineQosPolicyTypeSupport TypeSupport;
560  typedef DeadlineQosPolicyDataReader DataReader;
561  typedef DeadlineQosPolicyDataWriter DataWriter;
562  typedef DeadlineQosPolicyPtrSeq Seq;
563 
564  private:
565 
566  }; //DDS::DeadlineQosPolicy
567 
568  struct LatencyBudgetQosPolicy;
569  class LatencyBudgetQosPolicyTypeSupport;
570  class LatencyBudgetQosPolicyDataReader;
571  class LatencyBudgetQosPolicyDataWriter;
572 
573 /* DDS Data Type SEQUENCE: sequence<DDS::LatencyBudgetQosPolicy *> */
574 #ifndef _DDS_sequence_cpp_DDS_LatencyBudgetQosPolicyPtr_defined
575 #define _DDS_sequence_cpp_DDS_LatencyBudgetQosPolicyPtr_defined
576  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LatencyBudgetQosPolicy * , LatencyBudgetQosPolicyPtrSeq );
577 #endif /* DDS Data Type SEQUENCE: sequence<LatencyBudgetQosPolicyPtrSeq *> */
578 
593  struct COREDX_CPP_CLASS_API LatencyBudgetQosPolicy {
594  public:
596  LatencyBudgetQosPolicy();
597  ~LatencyBudgetQosPolicy();
598  LatencyBudgetQosPolicy( const LatencyBudgetQosPolicy & other );
599  LatencyBudgetQosPolicy& operator=( const LatencyBudgetQosPolicy & other);
600 
601  void init();
602  void clear();
603  void copy( const DDS::LatencyBudgetQosPolicy * instance );
604 
605  int get_marshal_size(int offset, int just_keys) const ;
606  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
607  unsigned char swap, int just_keys) const ;
608  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
609  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
610  unsigned char swap, int just_keys);
611  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
612 
613  /* Member vars*/
615  struct DDS::Duration_t duration;
616 
617  typedef LatencyBudgetQosPolicyTypeSupport TypeSupport;
618  typedef LatencyBudgetQosPolicyDataReader DataReader;
619  typedef LatencyBudgetQosPolicyDataWriter DataWriter;
620  typedef LatencyBudgetQosPolicyPtrSeq Seq;
621 
622  private:
623 
624  }; //DDS::LatencyBudgetQosPolicy
625 
626 
630  enum OwnershipQosPolicyKind { //unsigned int
632  SHARED_OWNERSHIP_QOS = 0,
634  EXCLUSIVE_OWNERSHIP_QOS = 1
635  };
636 
637  struct OwnershipQosPolicy;
638  class OwnershipQosPolicyTypeSupport;
639  class OwnershipQosPolicyDataReader;
640  class OwnershipQosPolicyDataWriter;
641 
642 /* DDS Data Type SEQUENCE: sequence<DDS::OwnershipQosPolicy *> */
643 #ifndef _DDS_sequence_cpp_DDS_OwnershipQosPolicyPtr_defined
644 #define _DDS_sequence_cpp_DDS_OwnershipQosPolicyPtr_defined
645  DECLARE_CPP_UNBOUNDED_SEQ( DDS::OwnershipQosPolicy * , OwnershipQosPolicyPtrSeq );
646 #endif /* DDS Data Type SEQUENCE: sequence<OwnershipQosPolicyPtrSeq *> */
647 
652  struct COREDX_CPP_CLASS_API OwnershipQosPolicy {
653  public:
655  OwnershipQosPolicy();
656  ~OwnershipQosPolicy();
657  OwnershipQosPolicy( const OwnershipQosPolicy & other );
658  OwnershipQosPolicy& operator=( const OwnershipQosPolicy & other);
659 
660  void init();
661  void clear();
662  void copy( const DDS::OwnershipQosPolicy * instance );
663 
664  int get_marshal_size(int offset, int just_keys) const ;
665  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
666  unsigned char swap, int just_keys) const ;
667  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
668  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
669  unsigned char swap, int just_keys);
670  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
671 
672  /* Member vars*/
674  enum DDS::OwnershipQosPolicyKind kind;
675 
676  typedef OwnershipQosPolicyTypeSupport TypeSupport;
677  typedef OwnershipQosPolicyDataReader DataReader;
678  typedef OwnershipQosPolicyDataWriter DataWriter;
679  typedef OwnershipQosPolicyPtrSeq Seq;
680 
681  private:
682 
683  }; //DDS::OwnershipQosPolicy
684 
685  struct OwnershipStrengthQosPolicy;
686  class OwnershipStrengthQosPolicyTypeSupport;
687  class OwnershipStrengthQosPolicyDataReader;
688  class OwnershipStrengthQosPolicyDataWriter;
689 
690 /* DDS Data Type SEQUENCE: sequence<DDS::OwnershipStrengthQosPolicy *> */
691 #ifndef _DDS_sequence_cpp_DDS_OwnershipStrengthQosPolicyPtr_defined
692 #define _DDS_sequence_cpp_DDS_OwnershipStrengthQosPolicyPtr_defined
693  DECLARE_CPP_UNBOUNDED_SEQ( DDS::OwnershipStrengthQosPolicy * , OwnershipStrengthQosPolicyPtrSeq );
694 #endif /* DDS Data Type SEQUENCE: sequence<OwnershipStrengthQosPolicyPtrSeq *> */
695 
704  struct COREDX_CPP_CLASS_API OwnershipStrengthQosPolicy {
705  public:
707  OwnershipStrengthQosPolicy();
708  ~OwnershipStrengthQosPolicy();
709  OwnershipStrengthQosPolicy( const OwnershipStrengthQosPolicy & other );
710  OwnershipStrengthQosPolicy& operator=( const OwnershipStrengthQosPolicy & other);
711 
712  void init();
713  void clear();
714  void copy( const DDS::OwnershipStrengthQosPolicy * instance );
715 
716  int get_marshal_size(int offset, int just_keys) const ;
717  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
718  unsigned char swap, int just_keys) const ;
719  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
720  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
721  unsigned char swap, int just_keys);
722  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
723 
724  /* Member vars*/
726  int value;
727 
728  typedef OwnershipStrengthQosPolicyTypeSupport TypeSupport;
729  typedef OwnershipStrengthQosPolicyDataReader DataReader;
730  typedef OwnershipStrengthQosPolicyDataWriter DataWriter;
731  typedef OwnershipStrengthQosPolicyPtrSeq Seq;
732 
733  private:
734 
735  }; //DDS::OwnershipStrengthQosPolicy
736 
737 
741  enum LivelinessQosPolicyKind { //unsigned int
743  AUTOMATIC_LIVELINESS_QOS = 0,
745  MANUAL_BY_PARTICIPANT_LIVELINESS_QOS = 1,
747  MANUAL_BY_TOPIC_LIVELINESS_QOS = 2
748  };
749 
750  struct LivelinessQosPolicy;
751  class LivelinessQosPolicyTypeSupport;
752  class LivelinessQosPolicyDataReader;
753  class LivelinessQosPolicyDataWriter;
754 
755 /* DDS Data Type SEQUENCE: sequence<DDS::LivelinessQosPolicy *> */
756 #ifndef _DDS_sequence_cpp_DDS_LivelinessQosPolicyPtr_defined
757 #define _DDS_sequence_cpp_DDS_LivelinessQosPolicyPtr_defined
758  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LivelinessQosPolicy * , LivelinessQosPolicyPtrSeq );
759 #endif /* DDS Data Type SEQUENCE: sequence<LivelinessQosPolicyPtrSeq *> */
760 
789  struct COREDX_CPP_CLASS_API LivelinessQosPolicy {
790  public:
792  LivelinessQosPolicy();
793  ~LivelinessQosPolicy();
794  LivelinessQosPolicy( const LivelinessQosPolicy & other );
795  LivelinessQosPolicy& operator=( const LivelinessQosPolicy & other);
796 
797  void init();
798  void clear();
799  void copy( const DDS::LivelinessQosPolicy * instance );
800 
801  int get_marshal_size(int offset, int just_keys) const ;
802  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
803  unsigned char swap, int just_keys) const ;
804  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
805  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
806  unsigned char swap, int just_keys);
807  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
808 
809  /* Member vars*/
811  enum DDS::LivelinessQosPolicyKind kind;
813  struct DDS::Duration_t lease_duration;
814 
815  typedef LivelinessQosPolicyTypeSupport TypeSupport;
816  typedef LivelinessQosPolicyDataReader DataReader;
817  typedef LivelinessQosPolicyDataWriter DataWriter;
818  typedef LivelinessQosPolicyPtrSeq Seq;
819 
820  private:
821 
822  }; //DDS::LivelinessQosPolicy
823 
824  struct TimeBasedFilterQosPolicy;
825  class TimeBasedFilterQosPolicyTypeSupport;
826  class TimeBasedFilterQosPolicyDataReader;
827  class TimeBasedFilterQosPolicyDataWriter;
828 
829 /* DDS Data Type SEQUENCE: sequence<DDS::TimeBasedFilterQosPolicy *> */
830 #ifndef _DDS_sequence_cpp_DDS_TimeBasedFilterQosPolicyPtr_defined
831 #define _DDS_sequence_cpp_DDS_TimeBasedFilterQosPolicyPtr_defined
832  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TimeBasedFilterQosPolicy * , TimeBasedFilterQosPolicyPtrSeq );
833 #endif /* DDS Data Type SEQUENCE: sequence<TimeBasedFilterQosPolicyPtrSeq *> */
834 
844  struct COREDX_CPP_CLASS_API TimeBasedFilterQosPolicy {
845  public:
847  TimeBasedFilterQosPolicy();
848  ~TimeBasedFilterQosPolicy();
849  TimeBasedFilterQosPolicy( const TimeBasedFilterQosPolicy & other );
850  TimeBasedFilterQosPolicy& operator=( const TimeBasedFilterQosPolicy & other);
851 
852  void init();
853  void clear();
854  void copy( const DDS::TimeBasedFilterQosPolicy * instance );
855 
856  int get_marshal_size(int offset, int just_keys) const ;
857  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
858  unsigned char swap, int just_keys) const ;
859  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
860  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
861  unsigned char swap, int just_keys);
862  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
863 
864  /* Member vars*/
866  struct DDS::Duration_t minimum_separation;
867 
868  typedef TimeBasedFilterQosPolicyTypeSupport TypeSupport;
869  typedef TimeBasedFilterQosPolicyDataReader DataReader;
870  typedef TimeBasedFilterQosPolicyDataWriter DataWriter;
871  typedef TimeBasedFilterQosPolicyPtrSeq Seq;
872 
873  private:
874 
875  }; //DDS::TimeBasedFilterQosPolicy
876 
877  struct PartitionQosPolicy;
878  class PartitionQosPolicyTypeSupport;
879  class PartitionQosPolicyDataReader;
880  class PartitionQosPolicyDataWriter;
881 
882 /* DDS Data Type SEQUENCE: sequence<DDS::PartitionQosPolicy *> */
883 #ifndef _DDS_sequence_cpp_DDS_PartitionQosPolicyPtr_defined
884 #define _DDS_sequence_cpp_DDS_PartitionQosPolicyPtr_defined
885  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PartitionQosPolicy * , PartitionQosPolicyPtrSeq );
886 #endif /* DDS Data Type SEQUENCE: sequence<PartitionQosPolicyPtrSeq *> */
887 
916  struct COREDX_CPP_CLASS_API PartitionQosPolicy {
917  public:
919  PartitionQosPolicy();
920  ~PartitionQosPolicy();
921  PartitionQosPolicy( const PartitionQosPolicy & other );
922  PartitionQosPolicy& operator=( const PartitionQosPolicy & other);
923 
924  void init();
925  void clear();
926  void copy( const DDS::PartitionQosPolicy * instance );
927 
928  int get_marshal_size(int offset, int just_keys) const ;
929  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
930  unsigned char swap, int just_keys) const ;
931  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
932  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
933  unsigned char swap, int just_keys);
934  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
935 
936  /* Member vars*/
938  DDS::StringSeq name;
939 
940  typedef PartitionQosPolicyTypeSupport TypeSupport;
941  typedef PartitionQosPolicyDataReader DataReader;
942  typedef PartitionQosPolicyDataWriter DataWriter;
943  typedef PartitionQosPolicyPtrSeq Seq;
944 
945  private:
946 
947  }; //DDS::PartitionQosPolicy
948 
949 
954  enum ReliabilityQosPolicyKind { //unsigned int
955  UNKN_RELIABILITY_QOS = 0,
957  BEST_EFFORT_RELIABILITY_QOS = 1,
959  RELIABLE_RELIABILITY_QOS = 2
960  };
961 
962  struct ReliabilityQosPolicy;
963  class ReliabilityQosPolicyTypeSupport;
964  class ReliabilityQosPolicyDataReader;
965  class ReliabilityQosPolicyDataWriter;
966 
967 /* DDS Data Type SEQUENCE: sequence<DDS::ReliabilityQosPolicy *> */
968 #ifndef _DDS_sequence_cpp_DDS_ReliabilityQosPolicyPtr_defined
969 #define _DDS_sequence_cpp_DDS_ReliabilityQosPolicyPtr_defined
970  DECLARE_CPP_UNBOUNDED_SEQ( DDS::ReliabilityQosPolicy * , ReliabilityQosPolicyPtrSeq );
971 #endif /* DDS Data Type SEQUENCE: sequence<ReliabilityQosPolicyPtrSeq *> */
972 
993  struct COREDX_CPP_CLASS_API ReliabilityQosPolicy {
994  public:
996  ReliabilityQosPolicy();
997  ~ReliabilityQosPolicy();
998  ReliabilityQosPolicy( const ReliabilityQosPolicy & other );
999  ReliabilityQosPolicy& operator=( const ReliabilityQosPolicy & other);
1000 
1001  void init();
1002  void clear();
1003  void copy( const DDS::ReliabilityQosPolicy * instance );
1004 
1005  int get_marshal_size(int offset, int just_keys) const ;
1006  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1007  unsigned char swap, int just_keys) const ;
1008  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1009  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1010  unsigned char swap, int just_keys);
1011  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1012 
1013  /* Member vars*/
1015  enum DDS::ReliabilityQosPolicyKind kind;
1017  struct DDS::Duration_t max_blocking_time;
1018 
1019  typedef ReliabilityQosPolicyTypeSupport TypeSupport;
1020  typedef ReliabilityQosPolicyDataReader DataReader;
1021  typedef ReliabilityQosPolicyDataWriter DataWriter;
1022  typedef ReliabilityQosPolicyPtrSeq Seq;
1023 
1024  private:
1025 
1026  }; //DDS::ReliabilityQosPolicy
1027 
1028 
1032  enum DestinationOrderQosPolicyKind { //unsigned int
1034  BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS = 0,
1036  BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS = 1
1037  };
1038 
1039  struct DestinationOrderQosPolicy;
1040  class DestinationOrderQosPolicyTypeSupport;
1041  class DestinationOrderQosPolicyDataReader;
1042  class DestinationOrderQosPolicyDataWriter;
1043 
1044 /* DDS Data Type SEQUENCE: sequence<DDS::DestinationOrderQosPolicy *> */
1045 #ifndef _DDS_sequence_cpp_DDS_DestinationOrderQosPolicyPtr_defined
1046 #define _DDS_sequence_cpp_DDS_DestinationOrderQosPolicyPtr_defined
1047  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DestinationOrderQosPolicy * , DestinationOrderQosPolicyPtrSeq );
1048 #endif /* DDS Data Type SEQUENCE: sequence<DestinationOrderQosPolicyPtrSeq *> */
1049 
1060  struct COREDX_CPP_CLASS_API DestinationOrderQosPolicy {
1061  public:
1063  DestinationOrderQosPolicy();
1064  ~DestinationOrderQosPolicy();
1065  DestinationOrderQosPolicy( const DestinationOrderQosPolicy & other );
1066  DestinationOrderQosPolicy& operator=( const DestinationOrderQosPolicy & other);
1067 
1068  void init();
1069  void clear();
1070  void copy( const DDS::DestinationOrderQosPolicy * instance );
1071 
1072  int get_marshal_size(int offset, int just_keys) const ;
1073  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1074  unsigned char swap, int just_keys) const ;
1075  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1076  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1077  unsigned char swap, int just_keys);
1078  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1079 
1080  /* Member vars*/
1082  enum DDS::DestinationOrderQosPolicyKind kind;
1083 
1084  typedef DestinationOrderQosPolicyTypeSupport TypeSupport;
1085  typedef DestinationOrderQosPolicyDataReader DataReader;
1086  typedef DestinationOrderQosPolicyDataWriter DataWriter;
1087  typedef DestinationOrderQosPolicyPtrSeq Seq;
1088 
1089  private:
1090 
1091  }; //DDS::DestinationOrderQosPolicy
1092 
1093 
1097  enum HistoryQosPolicyKind { //unsigned int
1099  KEEP_LAST_HISTORY_QOS = 0,
1102  KEEP_ALL_HISTORY_QOS = 1
1103  };
1104 
1105  struct HistoryQosPolicy;
1106  class HistoryQosPolicyTypeSupport;
1107  class HistoryQosPolicyDataReader;
1108  class HistoryQosPolicyDataWriter;
1109 
1110 /* DDS Data Type SEQUENCE: sequence<DDS::HistoryQosPolicy *> */
1111 #ifndef _DDS_sequence_cpp_DDS_HistoryQosPolicyPtr_defined
1112 #define _DDS_sequence_cpp_DDS_HistoryQosPolicyPtr_defined
1113  DECLARE_CPP_UNBOUNDED_SEQ( DDS::HistoryQosPolicy * , HistoryQosPolicyPtrSeq );
1114 #endif /* DDS Data Type SEQUENCE: sequence<HistoryQosPolicyPtrSeq *> */
1115 
1139  struct COREDX_CPP_CLASS_API HistoryQosPolicy {
1140  public:
1142  HistoryQosPolicy();
1143  ~HistoryQosPolicy();
1144  HistoryQosPolicy( const HistoryQosPolicy & other );
1145  HistoryQosPolicy& operator=( const HistoryQosPolicy & other);
1146 
1147  void init();
1148  void clear();
1149  void copy( const DDS::HistoryQosPolicy * instance );
1150 
1151  int get_marshal_size(int offset, int just_keys) const ;
1152  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1153  unsigned char swap, int just_keys) const ;
1154  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1155  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1156  unsigned char swap, int just_keys);
1157  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1158 
1159  /* Member vars*/
1161  enum DDS::HistoryQosPolicyKind kind;
1163  int depth;
1164 
1165  typedef HistoryQosPolicyTypeSupport TypeSupport;
1166  typedef HistoryQosPolicyDataReader DataReader;
1167  typedef HistoryQosPolicyDataWriter DataWriter;
1168  typedef HistoryQosPolicyPtrSeq Seq;
1169 
1170  private:
1171 
1172  }; //DDS::HistoryQosPolicy
1173 
1174  struct ResourceLimitsQosPolicy;
1175  class ResourceLimitsQosPolicyTypeSupport;
1176  class ResourceLimitsQosPolicyDataReader;
1177  class ResourceLimitsQosPolicyDataWriter;
1178 
1179 /* DDS Data Type SEQUENCE: sequence<DDS::ResourceLimitsQosPolicy *> */
1180 #ifndef _DDS_sequence_cpp_DDS_ResourceLimitsQosPolicyPtr_defined
1181 #define _DDS_sequence_cpp_DDS_ResourceLimitsQosPolicyPtr_defined
1182  DECLARE_CPP_UNBOUNDED_SEQ( DDS::ResourceLimitsQosPolicy * , ResourceLimitsQosPolicyPtrSeq );
1183 #endif /* DDS Data Type SEQUENCE: sequence<ResourceLimitsQosPolicyPtrSeq *> */
1184 
1193  struct COREDX_CPP_CLASS_API ResourceLimitsQosPolicy {
1194  public:
1196  ResourceLimitsQosPolicy();
1197  ~ResourceLimitsQosPolicy();
1198  ResourceLimitsQosPolicy( const ResourceLimitsQosPolicy & other );
1199  ResourceLimitsQosPolicy& operator=( const ResourceLimitsQosPolicy & other);
1200 
1201  void init();
1202  void clear();
1203  void copy( const DDS::ResourceLimitsQosPolicy * instance );
1204 
1205  int get_marshal_size(int offset, int just_keys) const ;
1206  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1207  unsigned char swap, int just_keys) const ;
1208  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1209  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1210  unsigned char swap, int just_keys);
1211  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1212 
1213  /* Member vars*/
1215  int max_samples;
1217  int max_instances;
1219  int max_samples_per_instance;
1222  unsigned char preallocate_samples;
1225  unsigned char preallocate_instances;
1226 
1227  typedef ResourceLimitsQosPolicyTypeSupport TypeSupport;
1228  typedef ResourceLimitsQosPolicyDataReader DataReader;
1229  typedef ResourceLimitsQosPolicyDataWriter DataWriter;
1230  typedef ResourceLimitsQosPolicyPtrSeq Seq;
1231 
1232  private:
1233 
1234  }; //DDS::ResourceLimitsQosPolicy
1235 
1236  struct DurabilityServiceQosPolicy;
1237  class DurabilityServiceQosPolicyTypeSupport;
1238  class DurabilityServiceQosPolicyDataReader;
1239  class DurabilityServiceQosPolicyDataWriter;
1240 
1241 /* DDS Data Type SEQUENCE: sequence<DDS::DurabilityServiceQosPolicy *> */
1242 #ifndef _DDS_sequence_cpp_DDS_DurabilityServiceQosPolicyPtr_defined
1243 #define _DDS_sequence_cpp_DDS_DurabilityServiceQosPolicyPtr_defined
1244  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DurabilityServiceQosPolicy * , DurabilityServiceQosPolicyPtrSeq );
1245 #endif /* DDS Data Type SEQUENCE: sequence<DurabilityServiceQosPolicyPtrSeq *> */
1246 
1270  struct COREDX_CPP_CLASS_API DurabilityServiceQosPolicy {
1271  public:
1273  DurabilityServiceQosPolicy();
1274  ~DurabilityServiceQosPolicy();
1275  DurabilityServiceQosPolicy( const DurabilityServiceQosPolicy & other );
1276  DurabilityServiceQosPolicy& operator=( const DurabilityServiceQosPolicy & other);
1277 
1278  void init();
1279  void clear();
1280  void copy( const DDS::DurabilityServiceQosPolicy * instance );
1281 
1282  int get_marshal_size(int offset, int just_keys) const ;
1283  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1284  unsigned char swap, int just_keys) const ;
1285  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1286  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1287  unsigned char swap, int just_keys);
1288  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1289 
1290  /* Member vars*/
1292  struct DDS::Duration_t service_cleanup_delay;
1294  enum DDS::HistoryQosPolicyKind history_kind;
1296  int history_depth;
1298  int max_samples;
1300  int max_instances;
1302  int max_samples_per_instance;
1303 
1304  typedef DurabilityServiceQosPolicyTypeSupport TypeSupport;
1305  typedef DurabilityServiceQosPolicyDataReader DataReader;
1306  typedef DurabilityServiceQosPolicyDataWriter DataWriter;
1307  typedef DurabilityServiceQosPolicyPtrSeq Seq;
1308 
1309  private:
1310 
1311  }; //DDS::DurabilityServiceQosPolicy
1312 
1313  typedef short DataRepresentationId_t; /* ns: DDS:: */
1314 
1315  static const DDS::DataRepresentationId_t XCDR_DATA_REPRESENTATION = 0; /* ns: DDS:: */
1316  static const DDS::DataRepresentationId_t XML_DATA_REPRESENTATION = 1; /* ns: DDS:: */
1317 #ifndef _DDS_SEQ_cpp_DDS_DDS_DataRepresentationId_tSeq_defined
1318 #define _DDS_SEQ_cpp_DDS_DDS_DataRepresentationId_tSeq_defined
1319  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationId_t , DDS_DataRepresentationId_tSeq );
1320 #endif /* User Defined SEQUENCE: sequence DDS::DataRepresentationId_tSeq */
1321 
1322  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationId_t , DataRepresentationIdSeq );
1323  struct DataRepresentationQosPolicy;
1324  class DataRepresentationQosPolicyTypeSupport;
1325  class DataRepresentationQosPolicyDataReader;
1326  class DataRepresentationQosPolicyDataWriter;
1327 
1328 /* DDS Data Type SEQUENCE: sequence<DDS::DataRepresentationQosPolicy *> */
1329 #ifndef _DDS_sequence_cpp_DDS_DataRepresentationQosPolicyPtr_defined
1330 #define _DDS_sequence_cpp_DDS_DataRepresentationQosPolicyPtr_defined
1331  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationQosPolicy * , DataRepresentationQosPolicyPtrSeq );
1332 #endif /* DDS Data Type SEQUENCE: sequence<DataRepresentationQosPolicyPtrSeq *> */
1333 
1348  struct COREDX_CPP_CLASS_API DataRepresentationQosPolicy {
1349  public:
1351  DataRepresentationQosPolicy();
1352  ~DataRepresentationQosPolicy();
1353  DataRepresentationQosPolicy( const DataRepresentationQosPolicy & other );
1354  DataRepresentationQosPolicy& operator=( const DataRepresentationQosPolicy & other);
1355 
1356  void init();
1357  void clear();
1358  void copy( const DDS::DataRepresentationQosPolicy * instance );
1359 
1360  int get_marshal_size(int offset, int just_keys) const ;
1361  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1362  unsigned char swap, int just_keys) const ;
1363  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1364  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1365  unsigned char swap, int just_keys);
1366  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1367 
1368  /* Member vars*/
1370  DDS::DataRepresentationIdSeq value;
1371 
1372  typedef DataRepresentationQosPolicyTypeSupport TypeSupport;
1373  typedef DataRepresentationQosPolicyDataReader DataReader;
1374  typedef DataRepresentationQosPolicyDataWriter DataWriter;
1375  typedef DataRepresentationQosPolicyPtrSeq Seq;
1376 
1377  private:
1378 
1379  }; //DDS::DataRepresentationQosPolicy
1380 
1381 
1385  enum TypeConsistencyKind { //unsigned short
1387  DISALLOW_TYPE_COERCION = 0,
1389  ALLOW_TYPE_COERCION = 1
1390  };
1391 
1392  struct TypeConsistencyEnforcementQosPolicy;
1393  class TypeConsistencyEnforcementQosPolicyTypeSupport;
1394  class TypeConsistencyEnforcementQosPolicyDataReader;
1395  class TypeConsistencyEnforcementQosPolicyDataWriter;
1396 
1397 /* DDS Data Type SEQUENCE: sequence<DDS::TypeConsistencyEnforcementQosPolicy *> */
1398 #ifndef _DDS_sequence_cpp_DDS_TypeConsistencyEnforcementQosPolicyPtr_defined
1399 #define _DDS_sequence_cpp_DDS_TypeConsistencyEnforcementQosPolicyPtr_defined
1400  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TypeConsistencyEnforcementQosPolicy * , TypeConsistencyEnforcementQosPolicyPtrSeq );
1401 #endif /* DDS Data Type SEQUENCE: sequence<TypeConsistencyEnforcementQosPolicyPtrSeq *> */
1402 
1409  struct COREDX_CPP_CLASS_API TypeConsistencyEnforcementQosPolicy {
1410  public:
1412  TypeConsistencyEnforcementQosPolicy();
1413  ~TypeConsistencyEnforcementQosPolicy();
1414  TypeConsistencyEnforcementQosPolicy( const TypeConsistencyEnforcementQosPolicy & other );
1415  TypeConsistencyEnforcementQosPolicy& operator=( const TypeConsistencyEnforcementQosPolicy & other);
1416 
1417  void init();
1418  void clear();
1419  void copy( const DDS::TypeConsistencyEnforcementQosPolicy * instance );
1420 
1421  int get_marshal_size(int offset, int just_keys) const ;
1422  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1423  unsigned char swap, int just_keys) const ;
1424  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1425  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1426  unsigned char swap, int just_keys);
1427  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1428 
1429  /* Member vars*/
1431  enum DDS::TypeConsistencyKind kind;
1432 
1433  typedef TypeConsistencyEnforcementQosPolicyTypeSupport TypeSupport;
1434  typedef TypeConsistencyEnforcementQosPolicyDataReader DataReader;
1435  typedef TypeConsistencyEnforcementQosPolicyDataWriter DataWriter;
1436  typedef TypeConsistencyEnforcementQosPolicyPtrSeq Seq;
1437 
1438  private:
1439 
1440  }; //DDS::TypeConsistencyEnforcementQosPolicy
1441 
1442  struct TypecodeQosPolicy;
1443  class TypecodeQosPolicyTypeSupport;
1444  class TypecodeQosPolicyDataReader;
1445  class TypecodeQosPolicyDataWriter;
1446 
1447 /* DDS Data Type SEQUENCE: sequence<DDS::TypecodeQosPolicy *> */
1448 #ifndef _DDS_sequence_cpp_DDS_TypecodeQosPolicyPtr_defined
1449 #define _DDS_sequence_cpp_DDS_TypecodeQosPolicyPtr_defined
1450  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TypecodeQosPolicy * , TypecodeQosPolicyPtrSeq );
1451 #endif /* DDS Data Type SEQUENCE: sequence<TypecodeQosPolicyPtrSeq *> */
1452 
1456  struct COREDX_CPP_CLASS_API TypecodeQosPolicy {
1457  public:
1459  TypecodeQosPolicy();
1460  ~TypecodeQosPolicy();
1461  TypecodeQosPolicy( const TypecodeQosPolicy & other );
1462  TypecodeQosPolicy& operator=( const TypecodeQosPolicy & other);
1463 
1464  void init();
1465  void clear();
1466  void copy( const DDS::TypecodeQosPolicy * instance );
1467 
1468  int get_marshal_size(int offset, int just_keys) const ;
1469  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1470  unsigned char swap, int just_keys) const ;
1471  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1472  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1473  unsigned char swap, int just_keys);
1474  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1475 
1476  /* Member vars*/
1478  DDS::OctetSeq value;
1480  unsigned char encoding;
1481 
1482  typedef TypecodeQosPolicyTypeSupport TypeSupport;
1483  typedef TypecodeQosPolicyDataReader DataReader;
1484  typedef TypecodeQosPolicyDataWriter DataWriter;
1485  typedef TypecodeQosPolicyPtrSeq Seq;
1486 
1487  private:
1488 
1489  }; //DDS::TypecodeQosPolicy
1490 
1491  static const unsigned char TYPECODE_BE = 0; /* ns: DDS:: */
1492  static const unsigned char TYPECODE_LE = 1; /* ns: DDS:: */
1493  static const unsigned char TYPEOBJ_BE = 16; /* ns: DDS:: */
1494  static const unsigned char TYPEOBJ_LE = 17; /* ns: DDS:: */
1495  static const int INSTANCE_NAME_MAXLEN = 255; /* ns: DDS:: */
1496  struct RpcQosPolicy;
1497  class RpcQosPolicyTypeSupport;
1498  class RpcQosPolicyDataReader;
1499  class RpcQosPolicyDataWriter;
1500 
1501 /* DDS Data Type SEQUENCE: sequence<DDS::RpcQosPolicy *> */
1502 #ifndef _DDS_sequence_cpp_DDS_RpcQosPolicyPtr_defined
1503 #define _DDS_sequence_cpp_DDS_RpcQosPolicyPtr_defined
1504  DECLARE_CPP_UNBOUNDED_SEQ( DDS::RpcQosPolicy * , RpcQosPolicyPtrSeq );
1505 #endif /* DDS Data Type SEQUENCE: sequence<RpcQosPolicyPtrSeq *> */
1506 
1510  struct COREDX_CPP_CLASS_API RpcQosPolicy {
1511  public:
1513  RpcQosPolicy();
1514  ~RpcQosPolicy();
1515  RpcQosPolicy( const RpcQosPolicy & other );
1516  RpcQosPolicy& operator=( const RpcQosPolicy & other);
1517 
1518 #ifndef _DDS_cpp_DDS_RpcQosPolicy_fixedstring255_t_defined
1519 #define _DDS_cpp_DDS_RpcQosPolicy_fixedstring255_t_defined
1520 typedef char fixedstring255_t[255+1];
1521 #endif /* User Defined Fixed-length String */
1522 
1523  void init();
1524  void clear();
1525  void copy( const DDS::RpcQosPolicy * instance );
1526 
1527  int get_marshal_size(int offset, int just_keys) const ;
1528  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1529  unsigned char swap, int just_keys) const ;
1530  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1531  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1532  unsigned char swap, int just_keys);
1533  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1534 
1535  /* Member vars*/
1537  fixedstring255_t service_instance_name;
1539  struct DDS::GUID_t related_entity_guid;
1541  DDS::StringSeq topic_aliases;
1542 
1543  typedef RpcQosPolicyTypeSupport TypeSupport;
1544  typedef RpcQosPolicyDataReader DataReader;
1545  typedef RpcQosPolicyDataWriter DataWriter;
1546  typedef RpcQosPolicyPtrSeq Seq;
1547 
1548  private:
1549 
1550  }; //DDS::RpcQosPolicy
1551 
1552  struct RTPSProperty_t;
1553  class RTPSProperty_tTypeSupport;
1554  class RTPSProperty_tDataReader;
1555  class RTPSProperty_tDataWriter;
1556 
1557 /* DDS Data Type SEQUENCE: sequence<DDS::RTPSProperty_t *> */
1558 #ifndef _DDS_sequence_cpp_DDS_RTPSProperty_tPtr_defined
1559 #define _DDS_sequence_cpp_DDS_RTPSProperty_tPtr_defined
1560  DECLARE_CPP_UNBOUNDED_SEQ( DDS::RTPSProperty_t * , RTPSProperty_tPtrSeq );
1561 #endif /* DDS Data Type SEQUENCE: sequence<RTPSProperty_tPtrSeq *> */
1562 
1563  struct COREDX_CPP_CLASS_API RTPSProperty_t {
1564  public:
1566  RTPSProperty_t();
1567  ~RTPSProperty_t();
1568  RTPSProperty_t( const RTPSProperty_t & other );
1569  RTPSProperty_t& operator=( const RTPSProperty_t & other);
1570 
1571  void init();
1572  void clear();
1573  void copy( const DDS::RTPSProperty_t * instance );
1574 
1575  int get_marshal_size(int offset, int just_keys) const ;
1576  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1577  unsigned char swap, int just_keys) const ;
1578  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1579  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1580  unsigned char swap, int just_keys);
1581  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1582 
1583  /* Member vars*/
1584  char * name;
1585  char * value;
1586 
1587  typedef RTPSProperty_tTypeSupport TypeSupport;
1588  typedef RTPSProperty_tDataReader DataReader;
1589  typedef RTPSProperty_tDataWriter DataWriter;
1590  typedef RTPSProperty_tPtrSeq Seq;
1591 
1592  private:
1593 
1594  }; //DDS::RTPSProperty_t
1595 
1596 #ifndef _DDS_SEQ_cpp_DDS_DDS_RTPSProperty_tSeq_defined
1597 #define _DDS_SEQ_cpp_DDS_DDS_RTPSProperty_tSeq_defined
1598  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::RTPSProperty_t , DDS_RTPSProperty_tSeq );
1599 #endif /* User Defined SEQUENCE: sequence DDS::RTPSProperty_tSeq */
1600 
1601  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::RTPSProperty_t , RTPSPropertySeq );
1602  struct Property_t;
1603  class Property_tTypeSupport;
1604  class Property_tDataReader;
1605  class Property_tDataWriter;
1606 
1607 /* DDS Data Type SEQUENCE: sequence<DDS::Property_t *> */
1608 #ifndef _DDS_sequence_cpp_DDS_Property_tPtr_defined
1609 #define _DDS_sequence_cpp_DDS_Property_tPtr_defined
1610  DECLARE_CPP_UNBOUNDED_SEQ( DDS::Property_t * , Property_tPtrSeq );
1611 #endif /* DDS Data Type SEQUENCE: sequence<Property_tPtrSeq *> */
1612 
1617  struct COREDX_CPP_CLASS_API Property_t {
1618  public:
1620  Property_t();
1621  ~Property_t();
1622  Property_t( const Property_t & other );
1623  Property_t& operator=( const Property_t & other);
1624 
1625  void init();
1626  void clear();
1627  void copy( const DDS::Property_t * instance );
1628 
1629  int get_marshal_size(int offset, int just_keys) const ;
1630  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1631  unsigned char swap, int just_keys) const ;
1632  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1633  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1634  unsigned char swap, int just_keys);
1635  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1636 
1637  /* Member vars*/
1639  char * name;
1641  char * value;
1643  unsigned char propagate;
1644 
1645  typedef Property_tTypeSupport TypeSupport;
1646  typedef Property_tDataReader DataReader;
1647  typedef Property_tDataWriter DataWriter;
1648  typedef Property_tPtrSeq Seq;
1649 
1650  private:
1651 
1652  }; //DDS::Property_t
1653 
1654 #ifndef _DDS_SEQ_cpp_DDS_DDS_Property_tSeq_defined
1655 #define _DDS_SEQ_cpp_DDS_DDS_Property_tSeq_defined
1656  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Property_t , DDS_Property_tSeq );
1657 #endif /* User Defined SEQUENCE: sequence DDS::Property_tSeq */
1658 
1659  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Property_t , PropertySeq );
1660  struct PropertyQosPolicy;
1661  class PropertyQosPolicyTypeSupport;
1662  class PropertyQosPolicyDataReader;
1663  class PropertyQosPolicyDataWriter;
1664 
1665 /* DDS Data Type SEQUENCE: sequence<DDS::PropertyQosPolicy *> */
1666 #ifndef _DDS_sequence_cpp_DDS_PropertyQosPolicyPtr_defined
1667 #define _DDS_sequence_cpp_DDS_PropertyQosPolicyPtr_defined
1668  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PropertyQosPolicy * , PropertyQosPolicyPtrSeq );
1669 #endif /* DDS Data Type SEQUENCE: sequence<PropertyQosPolicyPtrSeq *> */
1670 
1676  struct COREDX_CPP_CLASS_API PropertyQosPolicy {
1677  public:
1679  PropertyQosPolicy();
1680  ~PropertyQosPolicy();
1681  PropertyQosPolicy( const PropertyQosPolicy & other );
1682  PropertyQosPolicy& operator=( const PropertyQosPolicy & other);
1683 
1684  void init();
1685  void clear();
1686  void copy( const DDS::PropertyQosPolicy * instance );
1687 
1688  int get_marshal_size(int offset, int just_keys) const ;
1689  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1690  unsigned char swap, int just_keys) const ;
1691  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1692  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1693  unsigned char swap, int just_keys);
1694  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1695 
1696  /* Member vars*/
1698  DDS::PropertySeq value;
1699 
1700  typedef PropertyQosPolicyTypeSupport TypeSupport;
1701  typedef PropertyQosPolicyDataReader DataReader;
1702  typedef PropertyQosPolicyDataWriter DataWriter;
1703  typedef PropertyQosPolicyPtrSeq Seq;
1704 
1705  private:
1706 
1707  }; //DDS::PropertyQosPolicy
1708 
1709  struct DCPSParticipant;
1710  class DCPSParticipantTypeSupport;
1711  class DCPSParticipantDataReader;
1712  class DCPSParticipantDataWriter;
1713 
1714 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSParticipant *> */
1715 #ifndef _DDS_sequence_cpp_DDS_DCPSParticipantPtr_defined
1716 #define _DDS_sequence_cpp_DDS_DCPSParticipantPtr_defined
1717  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSParticipant * , DCPSParticipantPtrSeq );
1718 #endif /* DDS Data Type SEQUENCE: sequence<DCPSParticipantPtrSeq *> */
1719 
1723  struct COREDX_CPP_CLASS_API DCPSParticipant {
1724  public:
1726  DCPSParticipant();
1727  ~DCPSParticipant();
1728  DCPSParticipant( const DCPSParticipant & other );
1729  DCPSParticipant& operator=( const DCPSParticipant & other);
1730 
1731  void init();
1732  void clear();
1733  void copy( const DDS::DCPSParticipant * instance );
1734 
1735  int get_marshal_size(int offset, int just_keys) const ;
1736  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1737  unsigned char swap, int just_keys) const ;
1738  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1739  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1740  unsigned char swap, int just_keys);
1741  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1742 
1743  /* Member vars*/
1745  struct DDS::BuiltinTopicKey_t key; /* key */
1747  struct DDS::UserDataQosPolicy user_data;
1749  struct DDS::PropertyQosPolicy properties;
1751  char * entity_name;
1752 
1753  typedef DCPSParticipantTypeSupport TypeSupport;
1754  typedef DCPSParticipantDataReader DataReader;
1755  typedef DCPSParticipantDataWriter DataWriter;
1756  typedef DCPSParticipantPtrSeq Seq;
1757 
1758  private:
1759 
1760  }; //DDS::DCPSParticipant
1761 
1762  struct DCPSPublication;
1763  class DCPSPublicationTypeSupport;
1764  class DCPSPublicationDataReader;
1765  class DCPSPublicationDataWriter;
1766 
1767 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSPublication *> */
1768 #ifndef _DDS_sequence_cpp_DDS_DCPSPublicationPtr_defined
1769 #define _DDS_sequence_cpp_DDS_DCPSPublicationPtr_defined
1770  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSPublication * , DCPSPublicationPtrSeq );
1771 #endif /* DDS Data Type SEQUENCE: sequence<DCPSPublicationPtrSeq *> */
1772 
1776  struct COREDX_CPP_CLASS_API DCPSPublication {
1777  public:
1779  DCPSPublication();
1780  ~DCPSPublication();
1781  DCPSPublication( const DCPSPublication & other );
1782  DCPSPublication& operator=( const DCPSPublication & other);
1783 
1784  void init();
1785  void clear();
1786  void copy( const DDS::DCPSPublication * instance );
1787 
1788  int get_marshal_size(int offset, int just_keys) const ;
1789  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1790  unsigned char swap, int just_keys) const ;
1791  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1792  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1793  unsigned char swap, int just_keys);
1794  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1795 
1796  /* Member vars*/
1798  struct DDS::BuiltinTopicKey_t participant_key;
1800  struct DDS::BuiltinTopicKey_t key; /* key */
1802  char * topic_name;
1804  char * type_name;
1806  struct DDS::DurabilityQosPolicy durability;
1808  struct DDS::DurabilityServiceQosPolicy durability_service;
1810  struct DDS::DeadlineQosPolicy deadline;
1812  struct DDS::LatencyBudgetQosPolicy latency_budget;
1814  struct DDS::LivelinessQosPolicy liveliness;
1816  struct DDS::ReliabilityQosPolicy reliability;
1818  struct DDS::LifespanQosPolicy lifespan;
1820  struct DDS::UserDataQosPolicy user_data;
1822  struct DDS::OwnershipQosPolicy ownership;
1824  struct DDS::OwnershipStrengthQosPolicy ownership_strength;
1826  struct DDS::DestinationOrderQosPolicy destination_order;
1828  struct DDS::PresentationQosPolicy presentation;
1830  struct DDS::PartitionQosPolicy partition;
1832  struct DDS::TopicDataQosPolicy topic_data;
1834  struct DDS::GroupDataQosPolicy group_data;
1836  struct DDS::DataRepresentationQosPolicy representation;
1838  char * entity_name;
1839  struct DDS::TypecodeQosPolicy typecode;
1841  struct DDS::RpcQosPolicy rpc;
1842 
1843  typedef DCPSPublicationTypeSupport TypeSupport;
1844  typedef DCPSPublicationDataReader DataReader;
1845  typedef DCPSPublicationDataWriter DataWriter;
1846  typedef DCPSPublicationPtrSeq Seq;
1847 
1848  private:
1849 
1850  }; //DDS::DCPSPublication
1851 
1852  struct DCPSSubscription;
1853  class DCPSSubscriptionTypeSupport;
1854  class DCPSSubscriptionDataReader;
1855  class DCPSSubscriptionDataWriter;
1856 
1857 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSSubscription *> */
1858 #ifndef _DDS_sequence_cpp_DDS_DCPSSubscriptionPtr_defined
1859 #define _DDS_sequence_cpp_DDS_DCPSSubscriptionPtr_defined
1860  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSSubscription * , DCPSSubscriptionPtrSeq );
1861 #endif /* DDS Data Type SEQUENCE: sequence<DCPSSubscriptionPtrSeq *> */
1862 
1866  struct COREDX_CPP_CLASS_API DCPSSubscription {
1867  public:
1869  DCPSSubscription();
1870  ~DCPSSubscription();
1871  DCPSSubscription( const DCPSSubscription & other );
1872  DCPSSubscription& operator=( const DCPSSubscription & other);
1873 
1874  void init();
1875  void clear();
1876  void copy( const DDS::DCPSSubscription * instance );
1877 
1878  int get_marshal_size(int offset, int just_keys) const ;
1879  int marshal_cdr(unsigned char * buf, int offset, int stream_len,
1880  unsigned char swap, int just_keys) const ;
1881  int marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
1882  int unmarshal_cdr(unsigned char * buf, int offset, int stream_len,
1883  unsigned char swap, int just_keys);
1884  int unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);
1885 
1886  /* Member vars*/
1888  struct DDS::BuiltinTopicKey_t participant_key;
1890  struct DDS::BuiltinTopicKey_t key; /* key */
1892  char * topic_name;
1894  char * type_name;
1896  struct DDS::DurabilityQosPolicy durability;
1898  struct DDS::DeadlineQosPolicy deadline;
1900  struct DDS::LatencyBudgetQosPolicy latency_budget;
1902  struct DDS::LivelinessQosPolicy liveliness;
1904  struct DDS::ReliabilityQosPolicy reliability;
1906  struct DDS::OwnershipQosPolicy ownership;
1908  struct DDS::DestinationOrderQosPolicy destination_order;
1910  struct DDS::UserDataQosPolicy user_data;
1912  struct DDS::TimeBasedFilterQosPolicy time_based_filter;
1914  struct DDS::PresentationQosPolicy presentation;
1916  struct DDS::PartitionQosPolicy partition;
1918  struct DDS::TopicDataQosPolicy topic_data;
1920  struct DDS::GroupDataQosPolicy group_data;
1922  struct DDS::DataRepresentationQosPolicy representation;
1924  struct DDS::TypeConsistencyEnforcementQosPolicy type_consistency;
1926  char * entity_name;
1927  struct DDS::TypecodeQosPolicy typecode;
1929  struct DDS::RpcQosPolicy rpc;
1930 
1931  typedef DCPSSubscriptionTypeSupport TypeSupport;
1932  typedef DCPSSubscriptionDataReader DataReader;
1933  typedef DCPSSubscriptionDataWriter DataWriter;
1934  typedef DCPSSubscriptionPtrSeq Seq;
1935 
1936  private:
1937 
1938  }; //DDS::DCPSSubscription
1939 
1940 
1941  namespace rpc {
1942 
1943  typedef unsigned char UnknownOperation; /* ns: DDS::rpc:: */
1944 
1945  typedef unsigned char UnknownException; /* ns: DDS::rpc:: */
1946 
1947  typedef unsigned char UnusedMember; /* ns: DDS::rpc:: */
1948 
1949 
1950  } /* namespace rpc */
1951 
1952  } /* namespace DDS */
1953 
1954 #ifdef _MSC_VER
1955 # pragma warning(pop)
1956 #endif
1957 #endif
DDS::EXCLUSIVE_OWNERSHIP_QOS
DataReaders receive data published by the highest strength DataWriter for each Instance.
Definition: dds_builtin.hh:634
DDS::OwnershipQosPolicyKind
OwnershipQosPolicyKind
This enumeration contains the kinds of Ownership.
Definition: dds_builtin.hh:630
DDS::DCPSSubscription
Definition: dds_builtin.hh:1866
DDS::DurabilityServiceQosPolicy::max_samples
int max_samples
maximum samples limit for the service
Definition: dds_builtin.hh:1298
DDS::PresentationQosPolicyAccessScopeKind
PresentationQosPolicyAccessScopeKind
This enumeration contains the kinds of Access Scope for the PresentationQosPolicy.
Definition: dds_builtin.hh:442
DDS::DurabilityQosPolicyKind
DurabilityQosPolicyKind
This enumeration contains the kinds of Durability.
Definition: dds_builtin.hh:357
DDS::OwnershipQosPolicy
Determines instance ownership in the case of multple writers. CoreDX DDS supports both SHARED_OWNERSH...
Definition: dds_builtin.hh:652
DDS::DCPSPublication
Definition: dds_builtin.hh:1776
DDS::ReliabilityQosPolicyKind
ReliabilityQosPolicyKind
This enumeration contains the kinds of Reliability.
Definition: dds_builtin.hh:954
DDS::BEST_EFFORT_RELIABILITY_QOS
Best effort delivery – NO retransmission, HB, or ACKNACK.
Definition: dds_builtin.hh:957
DDS::DurabilityQosPolicy
The DurabilityQosPolicy controls the durablity of data.
Definition: dds_builtin.hh:405
DDS::OwnershipStrengthQosPolicy
Defines the strength, or priority, of a Writer. The strength is used to determine ownership in the ca...
Definition: dds_builtin.hh:704
DDS::GROUP_PRESENTATION_QOS
The scope is within samples published by DataWriters within the Publisher.
Definition: dds_builtin.hh:448
DDS::SHARED_OWNERSHIP_QOS
DataReaders receive data published by multiple DataWriters.
Definition: dds_builtin.hh:632
DDS::TransportPriorityQosPolicy
A hint to the middleware to help configure the transport priority mechanism.
Definition: dds_builtin.hh:269
DDS::HistoryQosPolicy::depth
int depth
history depth
Definition: dds_builtin.hh:1163
DDS::DataRepresentationQosPolicy::value
DDS::DataRepresentationIdSeq value
data representation
Definition: dds_builtin.hh:1370
DDS::TRANSIENT_DURABILITY_QOS
Definition: dds_builtin.hh:363
DDS::DataRepresentationQosPolicy
Describes the data representation used by a topic.
Definition: dds_builtin.hh:1348
DDS::TransportPriorityQosPolicy::value
int value
priority value
Definition: dds_builtin.hh:291
DDS::Property_t::value
char * value
the property value
Definition: dds_builtin.hh:1641
DDS::DataRepresentationId_t
short DataRepresentationId_t
Indicates the form of data, for example CDR or XML.
Definition: dds_builtin.hh:1313
DDS::ReliabilityQosPolicy
Indicates the level of reliability offered/provided by the Entity. If kind is RELIABLE_RELIABILITY_QO...
Definition: dds_builtin.hh:993
DDS::DurabilityServiceQosPolicy
Definition: dds_builtin.hh:1270
DDS::RpcQosPolicy::service_instance_name
fixedstring255_t service_instance_name
the name of the service instance
Definition: dds_builtin.hh:1537
DDS::AUTOMATIC_LIVELINESS_QOS
The DomainParticipant automatically asserts liveliness for all DataWriters within the DomainParticipa...
Definition: dds_builtin.hh:743
DDS::DCPSParticipant::entity_name
char * entity_name
arbitrary string name assigned to participant
Definition: dds_builtin.hh:1751
DDS::GroupDataQosPolicy::value
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:243
DDS::TopicDataQosPolicy::value
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:185
DDS::Property_t
A name-value pair property. The &#39;propagate&#39; flag indicates if this property should be transfered thro...
Definition: dds_builtin.hh:1617
DDS::DCPSPublication::topic_name
char * topic_name
the topic name
Definition: dds_builtin.hh:1802
DDS::RpcQosPolicy::topic_aliases
DDS::StringSeq topic_aliases
a sequence of aliases to support derived interfaces
Definition: dds_builtin.hh:1541
DDS::RELIABLE_RELIABILITY_QOS
Reliable delivery – HB, ACKNACK, and re-transmission.
Definition: dds_builtin.hh:959
DDS::DCPSSubscription::topic_name
char * topic_name
topic name config of this entity
Definition: dds_builtin.hh:1892
DDS::BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS
Use the reception time to determine the order of samples.
Definition: dds_builtin.hh:1034
DDS::GUID_t
Definition: dds_builtin_basic.hh:141
DDS::DestinationOrderQosPolicyKind
DestinationOrderQosPolicyKind
This enumeration contains the kinds of Destination Ordering.
Definition: dds_builtin.hh:1032
DDS::TypecodeQosPolicy
Typecode representing the datatype a DataReader reads or a DataWriter writes.
Definition: dds_builtin.hh:1456
DDS::LatencyBudgetQosPolicy
Specifies allowable latency.
Definition: dds_builtin.hh:593
DDS::DCPSParticipant
Definition: dds_builtin.hh:1723
DDS::BuiltinTopicKey_t
Definition: dds_builtin_basic.hh:42
DDS::RpcQosPolicy
Augment a DataWriter or DataReader with RPC specific information.
Definition: dds_builtin.hh:1510
DDS
Provides the DDS infrastructure.
Definition: dds_builtin_basic.hh:28
DDS::PresentationQosPolicy::ordered_access
unsigned char ordered_access
Determines if ordered access is supported within the defined &#39;scope&#39;.
Definition: dds_builtin.hh:494
DDS::MANUAL_BY_TOPIC_LIVELINESS_QOS
The application manually asserts the liveliness for each individual DataWriter by calling assert_live...
Definition: dds_builtin.hh:747
DDS::Property_t::name
char * name
the property name
Definition: dds_builtin.hh:1639
DDS::HistoryQosPolicy
Controls the ammount of historical data maintained by a DataReader or DataWriter. ...
Definition: dds_builtin.hh:1139
DDS::PERSISTENT_DURABILITY_QOS
Definition: dds_builtin.hh:365
DDS::PartitionQosPolicy
Defines a logical data partition.
Definition: dds_builtin.hh:916
DDS::DurabilityServiceQosPolicy::max_instances
int max_instances
maximum instances limit for the service
Definition: dds_builtin.hh:1300
DDS::ResourceLimitsQosPolicy::preallocate_instances
unsigned char preallocate_instances
Request that the Reader or Writer pre-allocate the specified number of instances (if max_instances is...
Definition: dds_builtin.hh:1225
DDS::UserDataQosPolicy
Allows the application to attach arbitrary information to a DomainParticipant, DataWriter or DataRead...
Definition: dds_builtin.hh:106
DDS::UserDataQosPolicy::value
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:128
DDS::INSTANCE_PRESENTATION_QOS
The scope is within an Instance.
Definition: dds_builtin.hh:444
DDS::KEEP_ALL_HISTORY_QOS
Store Samples for each Instance (up to the limits specified by ResourceLimitsQosPolicy) until the DDS...
Definition: dds_builtin.hh:1102
DDS::GroupDataQosPolicy
Allows the application to attach arbitrary information to a Publisher or Subscriber.
Definition: dds_builtin.hh:221
DDS::LivelinessQosPolicyKind
LivelinessQosPolicyKind
This enumeration contains the kinds of Liveliness.
Definition: dds_builtin.hh:741
DDS::TypeConsistencyEnforcementQosPolicy
rules for determining type consistency
Definition: dds_builtin.hh:1409
DDS::ResourceLimitsQosPolicy::max_samples
int max_samples
maximum samples allowed in the cache
Definition: dds_builtin.hh:1215
DDS::DCPSSubscription::entity_name
char * entity_name
entity name config of this entity
Definition: dds_builtin.hh:1926
DDS::DCPSSubscription::type_name
char * type_name
type name config of this entity
Definition: dds_builtin.hh:1894
DDS::PartitionQosPolicy::name
DDS::StringSeq name
sequence of partition names
Definition: dds_builtin.hh:938
DDS::PropertyQosPolicy
Definition: dds_builtin.hh:1676
DDS::ResourceLimitsQosPolicy::preallocate_samples
unsigned char preallocate_samples
Request that the Reader or Writer pre-allocate the specified number of samples (if max_samples is not...
Definition: dds_builtin.hh:1222
DDS::TRANSIENT_LOCAL_DURABILITY_QOS
The data is persisted locally within the source DataWriter.
Definition: dds_builtin.hh:361
DDS::ResourceLimitsQosPolicy::max_instances
int max_instances
maximum instances allowed in the cache
Definition: dds_builtin.hh:1217
DDS::DCPSPublication::type_name
char * type_name
type of the type
Definition: dds_builtin.hh:1804
DDS::TOPIC_PRESENTATION_QOS
The scope is within samples published by DataWriters on the Topic.
Definition: dds_builtin.hh:446
DDS::PresentationQosPolicy::coherent_access
unsigned char coherent_access
Determines if coherent access is supported within the defined &#39;scope&#39;.
Definition: dds_builtin.hh:492
DDS::DestinationOrderQosPolicy
This QoS policy controls how each Subscriber orders received data samples.
Definition: dds_builtin.hh:1060
DDS::TypecodeQosPolicy::encoding
unsigned char encoding
encoding of the typecode bytes (little endian / big endian
Definition: dds_builtin.hh:1480
DDS::Property_t::propagate
unsigned char propagate
propagate over discovery?
Definition: dds_builtin.hh:1643
DDS::OwnershipStrengthQosPolicy::value
int value
the ownership strength value
Definition: dds_builtin.hh:726
DDS::KEEP_LAST_HISTORY_QOS
Store at most depth Samples in the data cache for each Instance. Samples may be overwritten.
Definition: dds_builtin.hh:1099
DDS::HistoryQosPolicyKind
HistoryQosPolicyKind
This enumeration contains the kinds of History.
Definition: dds_builtin.hh:1097
DDS::PresentationQosPolicy
Controls the presentation of received data samples to the application. CoreDX DDS currently supports ...
Definition: dds_builtin.hh:467
DDS::LivelinessQosPolicy
Determines the mechanism and parameters used by the application to determine whether an Entity is ali...
Definition: dds_builtin.hh:789
DDS::TopicDataQosPolicy
Allows the application to attach arbitrary information to a Topic QoS.
Definition: dds_builtin.hh:163
DDS::ResourceLimitsQosPolicy::max_samples_per_instance
int max_samples_per_instance
maximum samples per instance allowed in the cache
Definition: dds_builtin.hh:1219
DDS::TypeConsistencyKind
TypeConsistencyKind
the allowed kinds of TypeConsistency
Definition: dds_builtin.hh:1385
DDS::DeadlineQosPolicy
This QoS policy establishes a minimum update period for data instances.
Definition: dds_builtin.hh:535
DDS::DurabilityServiceQosPolicy::max_samples_per_instance
int max_samples_per_instance
maximum samples per instance limit for the service
Definition: dds_builtin.hh:1302
DDS::VOLATILE_DURABILITY_QOS
The data is volatile, and is not persisted beyond the initial publication.
Definition: dds_builtin.hh:359
DDS::DISALLOW_TYPE_COERCION
Definition: dds_builtin.hh:1387
DDS::LifespanQosPolicy
Specifies the maximum duration of validity of the data written by the DataWriter. ...
Definition: dds_builtin.hh:320
DDS::TypecodeQosPolicy::value
DDS::OctetSeq value
sequence of bytes representing the TypeCode for the data type
Definition: dds_builtin.hh:1478
DDS::TimeBasedFilterQosPolicy
Defines a filter based on time between samples. The DataReader indicates that it wants at most one sa...
Definition: dds_builtin.hh:844
DDS::ALLOW_TYPE_COERCION
Definition: dds_builtin.hh:1389
DDS::Duration_t
The Duration_t structure contains data to define a time duration.
Definition: dds_builtin.hh:45
DDS::PropertyQosPolicy::value
DDS::PropertySeq value
sequence of Property_t&#39;s
Definition: dds_builtin.hh:1698
DDS::MANUAL_BY_PARTICIPANT_LIVELINESS_QOS
The application manually asserts the liveliness all DataWriters within this DomainParticipant by call...
Definition: dds_builtin.hh:745
DDS::ResourceLimitsQosPolicy
Specifies the resources that the Service can use to maintain data samples and instances.
Definition: dds_builtin.hh:1193
DDS::BY_SOURCE_TIMESTAMP_DESTINATIONORDER_QOS
Use the timestamp set by the publisher to determine the order of samples.
Definition: dds_builtin.hh:1036
DDS::DurabilityServiceQosPolicy::history_depth
int history_depth
history depth
Definition: dds_builtin.hh:1296
© 2009-2017 Twin Oaks Computing, Inc
Castle Rock, CO 80108
All rights reserved.