CoreDX Data Distribution Service
The High Performance, Small Footprint DDS from Twin Oaks Computing, Inc
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/xcdr.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_CPP_DDL_VERSION_MAJOR 5
20 # define DDS_BUILTIN_CPP_DDL_VERSION_MINOR 0
21 # define DDS_BUILTIN_CPP_DDL_VERSION_PATCH 0
22 # define DDS_BUILTIN_CPP_DDL_VERSION_MAJOR_STR "5"
23 # define DDS_BUILTIN_CPP_DDL_VERSION_MINOR_STR "0"
24 # define DDS_BUILTIN_CPP_DDL_VERSION_PATCH_STR "0"
25 
26 #include <dds/dds_builtin_basic.hh>
27 
28  namespace DDS {
29 
30  struct UserDataQosPolicy;
31  class UserDataQosPolicyTypeSupport;
32  class UserDataQosPolicyDataReader;
33  class UserDataQosPolicyDataWriter;
34 
35 /* DDS Data Type SEQUENCE: sequence<DDS::UserDataQosPolicy *> */
36 #ifndef _DDS_sequence_cpp_DDS_UserDataQosPolicyPtr_defined
37 #define _DDS_sequence_cpp_DDS_UserDataQosPolicyPtr_defined
38  DECLARE_CPP_UNBOUNDED_SEQ( DDS::UserDataQosPolicy *, UserDataQosPolicyPtrSeq );
39 #endif /* DDS Data Type SEQUENCE: sequence<UserDataQosPolicyPtrSeq *> */
40 
54  struct COREDX_TS_STRUCT_EXPORT UserDataQosPolicy {
55  public:
59  UserDataQosPolicy( const UserDataQosPolicy & other );
60  UserDataQosPolicy& operator=( const UserDataQosPolicy & other);
61 
62  void init();
63  void clear();
64  void copy( const DDS::UserDataQosPolicy * instance );
65 
66  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
67  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
68  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
69  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
70  // deprecated api:
71  int get_marshal_size( int offset, int just_keys) const;
72  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
73  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
74 
77 
78  typedef UserDataQosPolicyTypeSupport TypeSupport;
79  typedef UserDataQosPolicyDataReader DataReader;
80  typedef UserDataQosPolicyDataWriter DataWriter;
81  typedef UserDataQosPolicyPtrSeq Seq;
82 
83  private:
84 
85  }; //DDS::UserDataQosPolicy
86 
87  struct TopicDataQosPolicy;
88  class TopicDataQosPolicyTypeSupport;
89  class TopicDataQosPolicyDataReader;
90  class TopicDataQosPolicyDataWriter;
91 
92 /* DDS Data Type SEQUENCE: sequence<DDS::TopicDataQosPolicy *> */
93 #ifndef _DDS_sequence_cpp_DDS_TopicDataQosPolicyPtr_defined
94 #define _DDS_sequence_cpp_DDS_TopicDataQosPolicyPtr_defined
95  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TopicDataQosPolicy *, TopicDataQosPolicyPtrSeq );
96 #endif /* DDS Data Type SEQUENCE: sequence<TopicDataQosPolicyPtrSeq *> */
97 
111  struct COREDX_TS_STRUCT_EXPORT TopicDataQosPolicy {
112  public:
116  TopicDataQosPolicy( const TopicDataQosPolicy & other );
117  TopicDataQosPolicy& operator=( const TopicDataQosPolicy & other);
118 
119  void init();
120  void clear();
121  void copy( const DDS::TopicDataQosPolicy * instance );
122 
123  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
124  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
125  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
126  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
127  // deprecated api:
128  int get_marshal_size( int offset, int just_keys) const;
129  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
130  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
131 
134 
135  typedef TopicDataQosPolicyTypeSupport TypeSupport;
136  typedef TopicDataQosPolicyDataReader DataReader;
137  typedef TopicDataQosPolicyDataWriter DataWriter;
138  typedef TopicDataQosPolicyPtrSeq Seq;
139 
140  private:
141 
142  }; //DDS::TopicDataQosPolicy
143 
144  struct GroupDataQosPolicy;
145  class GroupDataQosPolicyTypeSupport;
146  class GroupDataQosPolicyDataReader;
147  class GroupDataQosPolicyDataWriter;
148 
149 /* DDS Data Type SEQUENCE: sequence<DDS::GroupDataQosPolicy *> */
150 #ifndef _DDS_sequence_cpp_DDS_GroupDataQosPolicyPtr_defined
151 #define _DDS_sequence_cpp_DDS_GroupDataQosPolicyPtr_defined
152  DECLARE_CPP_UNBOUNDED_SEQ( DDS::GroupDataQosPolicy *, GroupDataQosPolicyPtrSeq );
153 #endif /* DDS Data Type SEQUENCE: sequence<GroupDataQosPolicyPtrSeq *> */
154 
169  struct COREDX_TS_STRUCT_EXPORT GroupDataQosPolicy {
170  public:
174  GroupDataQosPolicy( const GroupDataQosPolicy & other );
175  GroupDataQosPolicy& operator=( const GroupDataQosPolicy & other);
176 
177  void init();
178  void clear();
179  void copy( const DDS::GroupDataQosPolicy * instance );
180 
181  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
182  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
183  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
184  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
185  // deprecated api:
186  int get_marshal_size( int offset, int just_keys) const;
187  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
188  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
189 
192 
193  typedef GroupDataQosPolicyTypeSupport TypeSupport;
194  typedef GroupDataQosPolicyDataReader DataReader;
195  typedef GroupDataQosPolicyDataWriter DataWriter;
196  typedef GroupDataQosPolicyPtrSeq Seq;
197 
198  private:
199 
200  }; //DDS::GroupDataQosPolicy
201 
203  class TransportPriorityQosPolicyTypeSupport;
204  class TransportPriorityQosPolicyDataReader;
205  class TransportPriorityQosPolicyDataWriter;
206 
207 /* DDS Data Type SEQUENCE: sequence<DDS::TransportPriorityQosPolicy *> */
208 #ifndef _DDS_sequence_cpp_DDS_TransportPriorityQosPolicyPtr_defined
209 #define _DDS_sequence_cpp_DDS_TransportPriorityQosPolicyPtr_defined
210  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TransportPriorityQosPolicy *, TransportPriorityQosPolicyPtrSeq );
211 #endif /* DDS Data Type SEQUENCE: sequence<TransportPriorityQosPolicyPtrSeq *> */
212 
217  struct COREDX_TS_STRUCT_EXPORT TransportPriorityQosPolicy {
218  public:
223  TransportPriorityQosPolicy& operator=( const TransportPriorityQosPolicy & other);
224 
225  void init();
226  void clear();
227  void copy( const DDS::TransportPriorityQosPolicy * instance );
228 
229  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
230  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
231  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
232  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
233  // deprecated api:
234  int get_marshal_size( int offset, int just_keys) const;
235  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
236  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
237 
239  int32_t value;
240 
241  typedef TransportPriorityQosPolicyTypeSupport TypeSupport;
242  typedef TransportPriorityQosPolicyDataReader DataReader;
243  typedef TransportPriorityQosPolicyDataWriter DataWriter;
244  typedef TransportPriorityQosPolicyPtrSeq Seq;
245 
246  private:
247 
248  }; //DDS::TransportPriorityQosPolicy
249 
250  struct LifespanQosPolicy;
251  class LifespanQosPolicyTypeSupport;
252  class LifespanQosPolicyDataReader;
253  class LifespanQosPolicyDataWriter;
254 
255 /* DDS Data Type SEQUENCE: sequence<DDS::LifespanQosPolicy *> */
256 #ifndef _DDS_sequence_cpp_DDS_LifespanQosPolicyPtr_defined
257 #define _DDS_sequence_cpp_DDS_LifespanQosPolicyPtr_defined
258  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LifespanQosPolicy *, LifespanQosPolicyPtrSeq );
259 #endif /* DDS Data Type SEQUENCE: sequence<LifespanQosPolicyPtrSeq *> */
260 
268  struct COREDX_TS_STRUCT_EXPORT LifespanQosPolicy {
269  public:
273  LifespanQosPolicy( const LifespanQosPolicy & other );
274  LifespanQosPolicy& operator=( const LifespanQosPolicy & other);
275 
276  void init();
277  void clear();
278  void copy( const DDS::LifespanQosPolicy * instance );
279 
280  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
281  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
282  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
283  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
284  // deprecated api:
285  int get_marshal_size( int offset, int just_keys) const;
286  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
287  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
288 
290  struct DDS::Duration_t duration;
291 
292  typedef LifespanQosPolicyTypeSupport TypeSupport;
293  typedef LifespanQosPolicyDataReader DataReader;
294  typedef LifespanQosPolicyDataWriter DataWriter;
295  typedef LifespanQosPolicyPtrSeq Seq;
296 
297  private:
298 
299  }; //DDS::LifespanQosPolicy
300 
301 
305  enum DurabilityQosPolicyKind { //uint32_t
314  };
315 
316  struct DurabilityQosPolicy;
317  class DurabilityQosPolicyTypeSupport;
318  class DurabilityQosPolicyDataReader;
319  class DurabilityQosPolicyDataWriter;
320 
321 /* DDS Data Type SEQUENCE: sequence<DDS::DurabilityQosPolicy *> */
322 #ifndef _DDS_sequence_cpp_DDS_DurabilityQosPolicyPtr_defined
323 #define _DDS_sequence_cpp_DDS_DurabilityQosPolicyPtr_defined
324  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DurabilityQosPolicy *, DurabilityQosPolicyPtrSeq );
325 #endif /* DDS Data Type SEQUENCE: sequence<DurabilityQosPolicyPtrSeq *> */
326 
353  struct COREDX_TS_STRUCT_EXPORT DurabilityQosPolicy {
354  public:
358  DurabilityQosPolicy( const DurabilityQosPolicy & other );
359  DurabilityQosPolicy& operator=( const DurabilityQosPolicy & other);
360 
361  void init();
362  void clear();
363  void copy( const DDS::DurabilityQosPolicy * instance );
364 
365  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
366  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
367  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
368  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
369  // deprecated api:
370  int get_marshal_size( int offset, int just_keys) const;
371  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
372  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
373 
376 
377  typedef DurabilityQosPolicyTypeSupport TypeSupport;
378  typedef DurabilityQosPolicyDataReader DataReader;
379  typedef DurabilityQosPolicyDataWriter DataWriter;
380  typedef DurabilityQosPolicyPtrSeq Seq;
381 
382  private:
383 
384  }; //DDS::DurabilityQosPolicy
385 
386 
397  };
398 
399  struct PresentationQosPolicy;
400  class PresentationQosPolicyTypeSupport;
401  class PresentationQosPolicyDataReader;
402  class PresentationQosPolicyDataWriter;
403 
404 /* DDS Data Type SEQUENCE: sequence<DDS::PresentationQosPolicy *> */
405 #ifndef _DDS_sequence_cpp_DDS_PresentationQosPolicyPtr_defined
406 #define _DDS_sequence_cpp_DDS_PresentationQosPolicyPtr_defined
407  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PresentationQosPolicy *, PresentationQosPolicyPtrSeq );
408 #endif /* DDS Data Type SEQUENCE: sequence<PresentationQosPolicyPtrSeq *> */
409 
415  struct COREDX_TS_STRUCT_EXPORT PresentationQosPolicy {
416  public:
421  PresentationQosPolicy& operator=( const PresentationQosPolicy & other);
422 
423  void init();
424  void clear();
425  void copy( const DDS::PresentationQosPolicy * instance );
426 
427  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
428  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
429  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
430  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
431  // deprecated api:
432  int get_marshal_size( int offset, int just_keys) const;
433  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
434  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
435 
440  unsigned char coherent_access;
442  unsigned char ordered_access;
443 
444  typedef PresentationQosPolicyTypeSupport TypeSupport;
445  typedef PresentationQosPolicyDataReader DataReader;
446  typedef PresentationQosPolicyDataWriter DataWriter;
447  typedef PresentationQosPolicyPtrSeq Seq;
448 
449  private:
450 
451  }; //DDS::PresentationQosPolicy
452 
453  struct DeadlineQosPolicy;
454  class DeadlineQosPolicyTypeSupport;
455  class DeadlineQosPolicyDataReader;
456  class DeadlineQosPolicyDataWriter;
457 
458 /* DDS Data Type SEQUENCE: sequence<DDS::DeadlineQosPolicy *> */
459 #ifndef _DDS_sequence_cpp_DDS_DeadlineQosPolicyPtr_defined
460 #define _DDS_sequence_cpp_DDS_DeadlineQosPolicyPtr_defined
461  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DeadlineQosPolicy *, DeadlineQosPolicyPtrSeq );
462 #endif /* DDS Data Type SEQUENCE: sequence<DeadlineQosPolicyPtrSeq *> */
463 
483  struct COREDX_TS_STRUCT_EXPORT DeadlineQosPolicy {
484  public:
488  DeadlineQosPolicy( const DeadlineQosPolicy & other );
489  DeadlineQosPolicy& operator=( const DeadlineQosPolicy & other);
490 
491  void init();
492  void clear();
493  void copy( const DDS::DeadlineQosPolicy * instance );
494 
495  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
496  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
497  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
498  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
499  // deprecated api:
500  int get_marshal_size( int offset, int just_keys) const;
501  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
502  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
503 
505  struct DDS::Duration_t period;
506 
507  typedef DeadlineQosPolicyTypeSupport TypeSupport;
508  typedef DeadlineQosPolicyDataReader DataReader;
509  typedef DeadlineQosPolicyDataWriter DataWriter;
510  typedef DeadlineQosPolicyPtrSeq Seq;
511 
512  private:
513 
514  }; //DDS::DeadlineQosPolicy
515 
516  struct LatencyBudgetQosPolicy;
517  class LatencyBudgetQosPolicyTypeSupport;
518  class LatencyBudgetQosPolicyDataReader;
519  class LatencyBudgetQosPolicyDataWriter;
520 
521 /* DDS Data Type SEQUENCE: sequence<DDS::LatencyBudgetQosPolicy *> */
522 #ifndef _DDS_sequence_cpp_DDS_LatencyBudgetQosPolicyPtr_defined
523 #define _DDS_sequence_cpp_DDS_LatencyBudgetQosPolicyPtr_defined
524  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LatencyBudgetQosPolicy *, LatencyBudgetQosPolicyPtrSeq );
525 #endif /* DDS Data Type SEQUENCE: sequence<LatencyBudgetQosPolicyPtrSeq *> */
526 
541  struct COREDX_TS_STRUCT_EXPORT LatencyBudgetQosPolicy {
542  public:
547  LatencyBudgetQosPolicy& operator=( const LatencyBudgetQosPolicy & other);
548 
549  void init();
550  void clear();
551  void copy( const DDS::LatencyBudgetQosPolicy * instance );
552 
553  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
554  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
555  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
556  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
557  // deprecated api:
558  int get_marshal_size( int offset, int just_keys) const;
559  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
560  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
561 
563  struct DDS::Duration_t duration;
564 
565  typedef LatencyBudgetQosPolicyTypeSupport TypeSupport;
566  typedef LatencyBudgetQosPolicyDataReader DataReader;
567  typedef LatencyBudgetQosPolicyDataWriter DataWriter;
568  typedef LatencyBudgetQosPolicyPtrSeq Seq;
569 
570  private:
571 
572  }; //DDS::LatencyBudgetQosPolicy
573 
574 
578  enum OwnershipQosPolicyKind { //uint32_t
583  };
584 
585  struct OwnershipQosPolicy;
586  class OwnershipQosPolicyTypeSupport;
587  class OwnershipQosPolicyDataReader;
588  class OwnershipQosPolicyDataWriter;
589 
590 /* DDS Data Type SEQUENCE: sequence<DDS::OwnershipQosPolicy *> */
591 #ifndef _DDS_sequence_cpp_DDS_OwnershipQosPolicyPtr_defined
592 #define _DDS_sequence_cpp_DDS_OwnershipQosPolicyPtr_defined
593  DECLARE_CPP_UNBOUNDED_SEQ( DDS::OwnershipQosPolicy *, OwnershipQosPolicyPtrSeq );
594 #endif /* DDS Data Type SEQUENCE: sequence<OwnershipQosPolicyPtrSeq *> */
595 
600  struct COREDX_TS_STRUCT_EXPORT OwnershipQosPolicy {
601  public:
605  OwnershipQosPolicy( const OwnershipQosPolicy & other );
606  OwnershipQosPolicy& operator=( const OwnershipQosPolicy & other);
607 
608  void init();
609  void clear();
610  void copy( const DDS::OwnershipQosPolicy * instance );
611 
612  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
613  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
614  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
615  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
616  // deprecated api:
617  int get_marshal_size( int offset, int just_keys) const;
618  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
619  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
620 
623 
624  typedef OwnershipQosPolicyTypeSupport TypeSupport;
625  typedef OwnershipQosPolicyDataReader DataReader;
626  typedef OwnershipQosPolicyDataWriter DataWriter;
627  typedef OwnershipQosPolicyPtrSeq Seq;
628 
629  private:
630 
631  }; //DDS::OwnershipQosPolicy
632 
634  class OwnershipStrengthQosPolicyTypeSupport;
635  class OwnershipStrengthQosPolicyDataReader;
636  class OwnershipStrengthQosPolicyDataWriter;
637 
638 /* DDS Data Type SEQUENCE: sequence<DDS::OwnershipStrengthQosPolicy *> */
639 #ifndef _DDS_sequence_cpp_DDS_OwnershipStrengthQosPolicyPtr_defined
640 #define _DDS_sequence_cpp_DDS_OwnershipStrengthQosPolicyPtr_defined
641  DECLARE_CPP_UNBOUNDED_SEQ( DDS::OwnershipStrengthQosPolicy *, OwnershipStrengthQosPolicyPtrSeq );
642 #endif /* DDS Data Type SEQUENCE: sequence<OwnershipStrengthQosPolicyPtrSeq *> */
643 
652  struct COREDX_TS_STRUCT_EXPORT OwnershipStrengthQosPolicy {
653  public:
658  OwnershipStrengthQosPolicy& operator=( const OwnershipStrengthQosPolicy & other);
659 
660  void init();
661  void clear();
662  void copy( const DDS::OwnershipStrengthQosPolicy * instance );
663 
664  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
665  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
666  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
667  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
668  // deprecated api:
669  int get_marshal_size( int offset, int just_keys) const;
670  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
671  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
672 
674  int32_t value;
675 
676  typedef OwnershipStrengthQosPolicyTypeSupport TypeSupport;
677  typedef OwnershipStrengthQosPolicyDataReader DataReader;
678  typedef OwnershipStrengthQosPolicyDataWriter DataWriter;
679  typedef OwnershipStrengthQosPolicyPtrSeq Seq;
680 
681  private:
682 
683  }; //DDS::OwnershipStrengthQosPolicy
684 
685 
689  enum LivelinessQosPolicyKind { //uint32_t
696  };
697 
698  struct LivelinessQosPolicy;
699  class LivelinessQosPolicyTypeSupport;
700  class LivelinessQosPolicyDataReader;
701  class LivelinessQosPolicyDataWriter;
702 
703 /* DDS Data Type SEQUENCE: sequence<DDS::LivelinessQosPolicy *> */
704 #ifndef _DDS_sequence_cpp_DDS_LivelinessQosPolicyPtr_defined
705 #define _DDS_sequence_cpp_DDS_LivelinessQosPolicyPtr_defined
706  DECLARE_CPP_UNBOUNDED_SEQ( DDS::LivelinessQosPolicy *, LivelinessQosPolicyPtrSeq );
707 #endif /* DDS Data Type SEQUENCE: sequence<LivelinessQosPolicyPtrSeq *> */
708 
737  struct COREDX_TS_STRUCT_EXPORT LivelinessQosPolicy {
738  public:
742  LivelinessQosPolicy( const LivelinessQosPolicy & other );
743  LivelinessQosPolicy& operator=( const LivelinessQosPolicy & other);
744 
745  void init();
746  void clear();
747  void copy( const DDS::LivelinessQosPolicy * instance );
748 
749  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
750  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
751  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
752  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
753  // deprecated api:
754  int get_marshal_size( int offset, int just_keys) const;
755  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
756  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
757 
761  struct DDS::Duration_t lease_duration;
762 
763  typedef LivelinessQosPolicyTypeSupport TypeSupport;
764  typedef LivelinessQosPolicyDataReader DataReader;
765  typedef LivelinessQosPolicyDataWriter DataWriter;
766  typedef LivelinessQosPolicyPtrSeq Seq;
767 
768  private:
769 
770  }; //DDS::LivelinessQosPolicy
771 
773  class TimeBasedFilterQosPolicyTypeSupport;
774  class TimeBasedFilterQosPolicyDataReader;
775  class TimeBasedFilterQosPolicyDataWriter;
776 
777 /* DDS Data Type SEQUENCE: sequence<DDS::TimeBasedFilterQosPolicy *> */
778 #ifndef _DDS_sequence_cpp_DDS_TimeBasedFilterQosPolicyPtr_defined
779 #define _DDS_sequence_cpp_DDS_TimeBasedFilterQosPolicyPtr_defined
780  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TimeBasedFilterQosPolicy *, TimeBasedFilterQosPolicyPtrSeq );
781 #endif /* DDS Data Type SEQUENCE: sequence<TimeBasedFilterQosPolicyPtrSeq *> */
782 
792  struct COREDX_TS_STRUCT_EXPORT TimeBasedFilterQosPolicy {
793  public:
798  TimeBasedFilterQosPolicy& operator=( const TimeBasedFilterQosPolicy & other);
799 
800  void init();
801  void clear();
802  void copy( const DDS::TimeBasedFilterQosPolicy * instance );
803 
804  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
805  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
806  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
807  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
808  // deprecated api:
809  int get_marshal_size( int offset, int just_keys) const;
810  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
811  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
812 
814  struct DDS::Duration_t minimum_separation;
815 
816  typedef TimeBasedFilterQosPolicyTypeSupport TypeSupport;
817  typedef TimeBasedFilterQosPolicyDataReader DataReader;
818  typedef TimeBasedFilterQosPolicyDataWriter DataWriter;
819  typedef TimeBasedFilterQosPolicyPtrSeq Seq;
820 
821  private:
822 
823  }; //DDS::TimeBasedFilterQosPolicy
824 
825  struct PartitionQosPolicy;
826  class PartitionQosPolicyTypeSupport;
827  class PartitionQosPolicyDataReader;
828  class PartitionQosPolicyDataWriter;
829 
830 /* DDS Data Type SEQUENCE: sequence<DDS::PartitionQosPolicy *> */
831 #ifndef _DDS_sequence_cpp_DDS_PartitionQosPolicyPtr_defined
832 #define _DDS_sequence_cpp_DDS_PartitionQosPolicyPtr_defined
833  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PartitionQosPolicy *, PartitionQosPolicyPtrSeq );
834 #endif /* DDS Data Type SEQUENCE: sequence<PartitionQosPolicyPtrSeq *> */
835 
864  struct COREDX_TS_STRUCT_EXPORT PartitionQosPolicy {
865  public:
869  PartitionQosPolicy( const PartitionQosPolicy & other );
870  PartitionQosPolicy& operator=( const PartitionQosPolicy & other);
871 
872  void init();
873  void clear();
874  void copy( const DDS::PartitionQosPolicy * instance );
875 
876  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
877  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
878  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
879  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
880  // deprecated api:
881  int get_marshal_size( int offset, int just_keys) const;
882  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
883  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
884 
887 
888  typedef PartitionQosPolicyTypeSupport TypeSupport;
889  typedef PartitionQosPolicyDataReader DataReader;
890  typedef PartitionQosPolicyDataWriter DataWriter;
891  typedef PartitionQosPolicyPtrSeq Seq;
892 
893  private:
894 
895  }; //DDS::PartitionQosPolicy
896 
897 
902  enum ReliabilityQosPolicyKind { //uint32_t
903  UNKN_RELIABILITY_QOS = 0,
908  };
909 
910  struct ReliabilityQosPolicy;
911  class ReliabilityQosPolicyTypeSupport;
912  class ReliabilityQosPolicyDataReader;
913  class ReliabilityQosPolicyDataWriter;
914 
915 /* DDS Data Type SEQUENCE: sequence<DDS::ReliabilityQosPolicy *> */
916 #ifndef _DDS_sequence_cpp_DDS_ReliabilityQosPolicyPtr_defined
917 #define _DDS_sequence_cpp_DDS_ReliabilityQosPolicyPtr_defined
918  DECLARE_CPP_UNBOUNDED_SEQ( DDS::ReliabilityQosPolicy *, ReliabilityQosPolicyPtrSeq );
919 #endif /* DDS Data Type SEQUENCE: sequence<ReliabilityQosPolicyPtrSeq *> */
920 
941  struct COREDX_TS_STRUCT_EXPORT ReliabilityQosPolicy {
942  public:
947  ReliabilityQosPolicy& operator=( const ReliabilityQosPolicy & other);
948 
949  void init();
950  void clear();
951  void copy( const DDS::ReliabilityQosPolicy * instance );
952 
953  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
954  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
955  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
956  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
957  // deprecated api:
958  int get_marshal_size( int offset, int just_keys) const;
959  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
960  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
961 
965  struct DDS::Duration_t max_blocking_time;
966 
967  typedef ReliabilityQosPolicyTypeSupport TypeSupport;
968  typedef ReliabilityQosPolicyDataReader DataReader;
969  typedef ReliabilityQosPolicyDataWriter DataWriter;
970  typedef ReliabilityQosPolicyPtrSeq Seq;
971 
972  private:
973 
974  }; //DDS::ReliabilityQosPolicy
975 
976 
980  enum DestinationOrderQosPolicyKind { //uint32_t
985  };
986 
988  class DestinationOrderQosPolicyTypeSupport;
989  class DestinationOrderQosPolicyDataReader;
990  class DestinationOrderQosPolicyDataWriter;
991 
992 /* DDS Data Type SEQUENCE: sequence<DDS::DestinationOrderQosPolicy *> */
993 #ifndef _DDS_sequence_cpp_DDS_DestinationOrderQosPolicyPtr_defined
994 #define _DDS_sequence_cpp_DDS_DestinationOrderQosPolicyPtr_defined
995  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DestinationOrderQosPolicy *, DestinationOrderQosPolicyPtrSeq );
996 #endif /* DDS Data Type SEQUENCE: sequence<DestinationOrderQosPolicyPtrSeq *> */
997 
1008  struct COREDX_TS_STRUCT_EXPORT DestinationOrderQosPolicy {
1009  public:
1014  DestinationOrderQosPolicy& operator=( const DestinationOrderQosPolicy & other);
1015 
1016  void init();
1017  void clear();
1018  void copy( const DDS::DestinationOrderQosPolicy * instance );
1019 
1020  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1021  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1022  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1023  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1024  // deprecated api:
1025  int get_marshal_size( int offset, int just_keys) const;
1026  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1027  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1028 
1031 
1032  typedef DestinationOrderQosPolicyTypeSupport TypeSupport;
1033  typedef DestinationOrderQosPolicyDataReader DataReader;
1034  typedef DestinationOrderQosPolicyDataWriter DataWriter;
1035  typedef DestinationOrderQosPolicyPtrSeq Seq;
1036 
1037  private:
1038 
1039  }; //DDS::DestinationOrderQosPolicy
1040 
1041 
1045  enum HistoryQosPolicyKind { //uint32_t
1051  };
1052 
1053  struct HistoryQosPolicy;
1054  class HistoryQosPolicyTypeSupport;
1055  class HistoryQosPolicyDataReader;
1056  class HistoryQosPolicyDataWriter;
1057 
1058 /* DDS Data Type SEQUENCE: sequence<DDS::HistoryQosPolicy *> */
1059 #ifndef _DDS_sequence_cpp_DDS_HistoryQosPolicyPtr_defined
1060 #define _DDS_sequence_cpp_DDS_HistoryQosPolicyPtr_defined
1061  DECLARE_CPP_UNBOUNDED_SEQ( DDS::HistoryQosPolicy *, HistoryQosPolicyPtrSeq );
1062 #endif /* DDS Data Type SEQUENCE: sequence<HistoryQosPolicyPtrSeq *> */
1063 
1087  struct COREDX_TS_STRUCT_EXPORT HistoryQosPolicy {
1088  public:
1090  HistoryQosPolicy();
1091  ~HistoryQosPolicy();
1092  HistoryQosPolicy( const HistoryQosPolicy & other );
1093  HistoryQosPolicy& operator=( const HistoryQosPolicy & other);
1094 
1095  void init();
1096  void clear();
1097  void copy( const DDS::HistoryQosPolicy * instance );
1098 
1099  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1100  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1101  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1102  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1103  // deprecated api:
1104  int get_marshal_size( int offset, int just_keys) const;
1105  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1106  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1107 
1111  int32_t depth;
1112 
1113  typedef HistoryQosPolicyTypeSupport TypeSupport;
1114  typedef HistoryQosPolicyDataReader DataReader;
1115  typedef HistoryQosPolicyDataWriter DataWriter;
1116  typedef HistoryQosPolicyPtrSeq Seq;
1117 
1118  private:
1119 
1120  }; //DDS::HistoryQosPolicy
1121 
1122  struct ResourceLimitsQosPolicy;
1123  class ResourceLimitsQosPolicyTypeSupport;
1124  class ResourceLimitsQosPolicyDataReader;
1125  class ResourceLimitsQosPolicyDataWriter;
1126 
1127 /* DDS Data Type SEQUENCE: sequence<DDS::ResourceLimitsQosPolicy *> */
1128 #ifndef _DDS_sequence_cpp_DDS_ResourceLimitsQosPolicyPtr_defined
1129 #define _DDS_sequence_cpp_DDS_ResourceLimitsQosPolicyPtr_defined
1130  DECLARE_CPP_UNBOUNDED_SEQ( DDS::ResourceLimitsQosPolicy *, ResourceLimitsQosPolicyPtrSeq );
1131 #endif /* DDS Data Type SEQUENCE: sequence<ResourceLimitsQosPolicyPtrSeq *> */
1132 
1141  struct COREDX_TS_STRUCT_EXPORT ResourceLimitsQosPolicy {
1142  public:
1147  ResourceLimitsQosPolicy& operator=( const ResourceLimitsQosPolicy & other);
1148 
1149  void init();
1150  void clear();
1151  void copy( const DDS::ResourceLimitsQosPolicy * instance );
1152 
1153  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1154  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1155  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1156  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1157  // deprecated api:
1158  int get_marshal_size( int offset, int just_keys) const;
1159  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1160  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1161 
1163  int32_t max_samples;
1165  int32_t max_instances;
1170  unsigned char preallocate_samples;
1173  unsigned char preallocate_instances;
1174 
1175  typedef ResourceLimitsQosPolicyTypeSupport TypeSupport;
1176  typedef ResourceLimitsQosPolicyDataReader DataReader;
1177  typedef ResourceLimitsQosPolicyDataWriter DataWriter;
1178  typedef ResourceLimitsQosPolicyPtrSeq Seq;
1179 
1180  private:
1181 
1182  }; //DDS::ResourceLimitsQosPolicy
1183 
1185  class DurabilityServiceQosPolicyTypeSupport;
1186  class DurabilityServiceQosPolicyDataReader;
1187  class DurabilityServiceQosPolicyDataWriter;
1188 
1189 /* DDS Data Type SEQUENCE: sequence<DDS::DurabilityServiceQosPolicy *> */
1190 #ifndef _DDS_sequence_cpp_DDS_DurabilityServiceQosPolicyPtr_defined
1191 #define _DDS_sequence_cpp_DDS_DurabilityServiceQosPolicyPtr_defined
1192  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DurabilityServiceQosPolicy *, DurabilityServiceQosPolicyPtrSeq );
1193 #endif /* DDS Data Type SEQUENCE: sequence<DurabilityServiceQosPolicyPtrSeq *> */
1194 
1218  struct COREDX_TS_STRUCT_EXPORT DurabilityServiceQosPolicy {
1219  public:
1224  DurabilityServiceQosPolicy& operator=( const DurabilityServiceQosPolicy & other);
1225 
1226  void init();
1227  void clear();
1228  void copy( const DDS::DurabilityServiceQosPolicy * instance );
1229 
1230  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1231  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1232  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1233  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1234  // deprecated api:
1235  int get_marshal_size( int offset, int just_keys) const;
1236  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1237  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1238 
1240  struct DDS::Duration_t service_cleanup_delay;
1242  enum DDS::HistoryQosPolicyKind history_kind;
1244  int32_t history_depth;
1246  int32_t max_samples;
1248  int32_t max_instances;
1251 
1252  typedef DurabilityServiceQosPolicyTypeSupport TypeSupport;
1253  typedef DurabilityServiceQosPolicyDataReader DataReader;
1254  typedef DurabilityServiceQosPolicyDataWriter DataWriter;
1255  typedef DurabilityServiceQosPolicyPtrSeq Seq;
1256 
1257  private:
1258 
1259  }; //DDS::DurabilityServiceQosPolicy
1260 
1261  typedef int16_t DataRepresentationId_t; /* ns: DDS:: */
1262 
1263  static const DDS::DataRepresentationId_t XCDR_DATA_REPRESENTATION = 0; /* ns: DDS:: */
1264  static const DDS::DataRepresentationId_t XML_DATA_REPRESENTATION = 1; /* ns: DDS:: */
1265 #ifndef _DDS_SEQ_cpp_DDS_DDS_DataRepresentationId_tSeq_defined
1266 #define _DDS_SEQ_cpp_DDS_DDS_DataRepresentationId_tSeq_defined
1267  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationId_t, DDS_DataRepresentationId_tSeq );
1268 #endif /* User Defined SEQUENCE: sequence DDS::DataRepresentationId_tSeq */
1269 
1270  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationId_t, DataRepresentationIdSeq );
1272  class DataRepresentationQosPolicyTypeSupport;
1273  class DataRepresentationQosPolicyDataReader;
1274  class DataRepresentationQosPolicyDataWriter;
1275 
1276 /* DDS Data Type SEQUENCE: sequence<DDS::DataRepresentationQosPolicy *> */
1277 #ifndef _DDS_sequence_cpp_DDS_DataRepresentationQosPolicyPtr_defined
1278 #define _DDS_sequence_cpp_DDS_DataRepresentationQosPolicyPtr_defined
1279  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataRepresentationQosPolicy *, DataRepresentationQosPolicyPtrSeq );
1280 #endif /* DDS Data Type SEQUENCE: sequence<DataRepresentationQosPolicyPtrSeq *> */
1281 
1296  struct COREDX_TS_STRUCT_EXPORT DataRepresentationQosPolicy {
1297  public:
1302  DataRepresentationQosPolicy& operator=( const DataRepresentationQosPolicy & other);
1303 
1304  void init();
1305  void clear();
1306  void copy( const DDS::DataRepresentationQosPolicy * instance );
1307 
1308  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1309  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1310  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1311  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1312  // deprecated api:
1313  int get_marshal_size( int offset, int just_keys) const;
1314  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1315  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1316 
1318  DDS::DataRepresentationIdSeq value;
1319 
1320  typedef DataRepresentationQosPolicyTypeSupport TypeSupport;
1321  typedef DataRepresentationQosPolicyDataReader DataReader;
1322  typedef DataRepresentationQosPolicyDataWriter DataWriter;
1323  typedef DataRepresentationQosPolicyPtrSeq Seq;
1324 
1325  private:
1326 
1327  }; //DDS::DataRepresentationQosPolicy
1328 
1329 
1333  enum TypeConsistencyKind { //uint16_t
1338  };
1339 
1341  class TypeConsistencyEnforcementQosPolicyTypeSupport;
1342  class TypeConsistencyEnforcementQosPolicyDataReader;
1343  class TypeConsistencyEnforcementQosPolicyDataWriter;
1344 
1345 /* DDS Data Type SEQUENCE: sequence<DDS::TypeConsistencyEnforcementQosPolicy *> */
1346 #ifndef _DDS_sequence_cpp_DDS_TypeConsistencyEnforcementQosPolicyPtr_defined
1347 #define _DDS_sequence_cpp_DDS_TypeConsistencyEnforcementQosPolicyPtr_defined
1348  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TypeConsistencyEnforcementQosPolicy *, TypeConsistencyEnforcementQosPolicyPtrSeq );
1349 #endif /* DDS Data Type SEQUENCE: sequence<TypeConsistencyEnforcementQosPolicyPtrSeq *> */
1350 
1357  struct COREDX_TS_STRUCT_EXPORT TypeConsistencyEnforcementQosPolicy {
1358  public:
1364 
1365  void init();
1366  void clear();
1367  void copy( const DDS::TypeConsistencyEnforcementQosPolicy * instance );
1368 
1369  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1370  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1371  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1372  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1373  // deprecated api:
1374  int get_marshal_size( int offset, int just_keys) const;
1375  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1376  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1377 
1380 
1381  typedef TypeConsistencyEnforcementQosPolicyTypeSupport TypeSupport;
1382  typedef TypeConsistencyEnforcementQosPolicyDataReader DataReader;
1383  typedef TypeConsistencyEnforcementQosPolicyDataWriter DataWriter;
1384  typedef TypeConsistencyEnforcementQosPolicyPtrSeq Seq;
1385 
1386  private:
1387 
1388  }; //DDS::TypeConsistencyEnforcementQosPolicy
1389 
1390  struct TypecodeQosPolicy;
1391  class TypecodeQosPolicyTypeSupport;
1392  class TypecodeQosPolicyDataReader;
1393  class TypecodeQosPolicyDataWriter;
1394 
1395 /* DDS Data Type SEQUENCE: sequence<DDS::TypecodeQosPolicy *> */
1396 #ifndef _DDS_sequence_cpp_DDS_TypecodeQosPolicyPtr_defined
1397 #define _DDS_sequence_cpp_DDS_TypecodeQosPolicyPtr_defined
1398  DECLARE_CPP_UNBOUNDED_SEQ( DDS::TypecodeQosPolicy *, TypecodeQosPolicyPtrSeq );
1399 #endif /* DDS Data Type SEQUENCE: sequence<TypecodeQosPolicyPtrSeq *> */
1400 
1404  struct COREDX_TS_STRUCT_EXPORT TypecodeQosPolicy {
1405  public:
1408  ~TypecodeQosPolicy();
1409  TypecodeQosPolicy( const TypecodeQosPolicy & other );
1410  TypecodeQosPolicy& operator=( const TypecodeQosPolicy & other);
1411 
1412  void init();
1413  void clear();
1414  void copy( const DDS::TypecodeQosPolicy * instance );
1415 
1416  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1417  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1418  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1419  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1420  // deprecated api:
1421  int get_marshal_size( int offset, int just_keys) const;
1422  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1423  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1424 
1428  unsigned char encoding;
1429 
1430  typedef TypecodeQosPolicyTypeSupport TypeSupport;
1431  typedef TypecodeQosPolicyDataReader DataReader;
1432  typedef TypecodeQosPolicyDataWriter DataWriter;
1433  typedef TypecodeQosPolicyPtrSeq Seq;
1434 
1435  private:
1436 
1437  }; //DDS::TypecodeQosPolicy
1438 
1439  static const unsigned char TYPECODE_BE = 0x00; /* ns: DDS:: */
1440  static const unsigned char TYPECODE_LE = 0x01; /* ns: DDS:: */
1441  static const unsigned char TYPEOBJ_BE = 0x10; /* ns: DDS:: */
1442  static const unsigned char TYPEOBJ_LE = 0x11; /* ns: DDS:: */
1443  static const int32_t INSTANCE_NAME_MAXLEN = 255; /* ns: DDS:: */
1444  struct RpcQosPolicy;
1445  class RpcQosPolicyTypeSupport;
1446  class RpcQosPolicyDataReader;
1447  class RpcQosPolicyDataWriter;
1448 
1449 /* DDS Data Type SEQUENCE: sequence<DDS::RpcQosPolicy *> */
1450 #ifndef _DDS_sequence_cpp_DDS_RpcQosPolicyPtr_defined
1451 #define _DDS_sequence_cpp_DDS_RpcQosPolicyPtr_defined
1452  DECLARE_CPP_UNBOUNDED_SEQ( DDS::RpcQosPolicy *, RpcQosPolicyPtrSeq );
1453 #endif /* DDS Data Type SEQUENCE: sequence<RpcQosPolicyPtrSeq *> */
1454 
1458  struct COREDX_TS_STRUCT_EXPORT RpcQosPolicy {
1459  public:
1461  RpcQosPolicy();
1462  ~RpcQosPolicy();
1463  RpcQosPolicy( const RpcQosPolicy & other );
1464  RpcQosPolicy& operator=( const RpcQosPolicy & other);
1465 
1466 #ifndef _DDS_cpp_DDS_RpcQosPolicy_fixedstring255_t_defined
1467 #define _DDS_cpp_DDS_RpcQosPolicy_fixedstring255_t_defined
1468 typedef char fixedstring255_t[255+1];
1469 #endif /* User Defined Fixed-length String */
1470 
1471  void init();
1472  void clear();
1473  void copy( const DDS::RpcQosPolicy * instance );
1474 
1475  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1476  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1477  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1478  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1479  // deprecated api:
1480  int get_marshal_size( int offset, int just_keys) const;
1481  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1482  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1483 
1485  fixedstring255_t service_instance_name;
1487  struct DDS::GUID_t related_entity_guid;
1490 
1491  typedef RpcQosPolicyTypeSupport TypeSupport;
1492  typedef RpcQosPolicyDataReader DataReader;
1493  typedef RpcQosPolicyDataWriter DataWriter;
1494  typedef RpcQosPolicyPtrSeq Seq;
1495 
1496  private:
1497 
1498  }; //DDS::RpcQosPolicy
1499 
1500  struct RTPSProperty_t;
1501  class RTPSProperty_tTypeSupport;
1502  class RTPSProperty_tDataReader;
1503  class RTPSProperty_tDataWriter;
1504 
1505 /* DDS Data Type SEQUENCE: sequence<DDS::RTPSProperty_t *> */
1506 #ifndef _DDS_sequence_cpp_DDS_RTPSProperty_tPtr_defined
1507 #define _DDS_sequence_cpp_DDS_RTPSProperty_tPtr_defined
1508  DECLARE_CPP_UNBOUNDED_SEQ( DDS::RTPSProperty_t *, RTPSProperty_tPtrSeq );
1509 #endif /* DDS Data Type SEQUENCE: sequence<RTPSProperty_tPtrSeq *> */
1510 
1511  struct COREDX_TS_STRUCT_EXPORT RTPSProperty_t {
1512  public:
1514  RTPSProperty_t();
1515  ~RTPSProperty_t();
1516  RTPSProperty_t( const RTPSProperty_t & other );
1517  RTPSProperty_t& operator=( const RTPSProperty_t & other);
1518 
1519  void init();
1520  void clear();
1521  void copy( const DDS::RTPSProperty_t * instance );
1522 
1523  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1524  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1525  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1526  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1527  // deprecated api:
1528  int get_marshal_size( int offset, int just_keys) const;
1529  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1530  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1531 
1532  char * name;
1533  char * value;
1534 
1535  typedef RTPSProperty_tTypeSupport TypeSupport;
1536  typedef RTPSProperty_tDataReader DataReader;
1537  typedef RTPSProperty_tDataWriter DataWriter;
1538  typedef RTPSProperty_tPtrSeq Seq;
1539 
1540  private:
1541 
1542  }; //DDS::RTPSProperty_t
1543 
1544 #ifndef _DDS_SEQ_cpp_DDS_DDS_RTPSProperty_tSeq_defined
1545 #define _DDS_SEQ_cpp_DDS_DDS_RTPSProperty_tSeq_defined
1546  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::RTPSProperty_t, DDS_RTPSProperty_tSeq );
1547 #endif /* User Defined SEQUENCE: sequence DDS::RTPSProperty_tSeq */
1548 
1549  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::RTPSProperty_t, RTPSPropertySeq );
1550  struct Property_t;
1551  class Property_tTypeSupport;
1552  class Property_tDataReader;
1553  class Property_tDataWriter;
1554 
1555 /* DDS Data Type SEQUENCE: sequence<DDS::Property_t *> */
1556 #ifndef _DDS_sequence_cpp_DDS_Property_tPtr_defined
1557 #define _DDS_sequence_cpp_DDS_Property_tPtr_defined
1558  DECLARE_CPP_UNBOUNDED_SEQ( DDS::Property_t *, Property_tPtrSeq );
1559 #endif /* DDS Data Type SEQUENCE: sequence<Property_tPtrSeq *> */
1560 
1565  struct COREDX_TS_STRUCT_EXPORT Property_t {
1566  public:
1568  Property_t();
1569  ~Property_t();
1570  Property_t( const Property_t & other );
1571  Property_t& operator=( const Property_t & other);
1572 
1573  void init();
1574  void clear();
1575  void copy( const DDS::Property_t * instance );
1576 
1577  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1578  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1579  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1580  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1581  // deprecated api:
1582  int get_marshal_size( int offset, int just_keys) const;
1583  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1584  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1585 
1587  char * name;
1589  char * value;
1591  unsigned char propagate;
1592 
1593  typedef Property_tTypeSupport TypeSupport;
1594  typedef Property_tDataReader DataReader;
1595  typedef Property_tDataWriter DataWriter;
1596  typedef Property_tPtrSeq Seq;
1597 
1598  private:
1599 
1600  }; //DDS::Property_t
1601 
1602 #ifndef _DDS_SEQ_cpp_DDS_DDS_Property_tSeq_defined
1603 #define _DDS_SEQ_cpp_DDS_DDS_Property_tSeq_defined
1604  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Property_t, DDS_Property_tSeq );
1605 #endif /* User Defined SEQUENCE: sequence DDS::Property_tSeq */
1606 
1607  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Property_t, PropertySeq );
1608  struct PropertyQosPolicy;
1609  class PropertyQosPolicyTypeSupport;
1610  class PropertyQosPolicyDataReader;
1611  class PropertyQosPolicyDataWriter;
1612 
1613 /* DDS Data Type SEQUENCE: sequence<DDS::PropertyQosPolicy *> */
1614 #ifndef _DDS_sequence_cpp_DDS_PropertyQosPolicyPtr_defined
1615 #define _DDS_sequence_cpp_DDS_PropertyQosPolicyPtr_defined
1616  DECLARE_CPP_UNBOUNDED_SEQ( DDS::PropertyQosPolicy *, PropertyQosPolicyPtrSeq );
1617 #endif /* DDS Data Type SEQUENCE: sequence<PropertyQosPolicyPtrSeq *> */
1618 
1624  struct COREDX_TS_STRUCT_EXPORT PropertyQosPolicy {
1625  public:
1628  ~PropertyQosPolicy();
1629  PropertyQosPolicy( const PropertyQosPolicy & other );
1630  PropertyQosPolicy& operator=( const PropertyQosPolicy & other);
1631 
1632  void init();
1633  void clear();
1634  void copy( const DDS::PropertyQosPolicy * instance );
1635 
1636  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1637  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1638  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1639  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1640  // deprecated api:
1641  int get_marshal_size( int offset, int just_keys) const;
1642  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1643  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1644 
1646  DDS::PropertySeq value;
1647 
1648  typedef PropertyQosPolicyTypeSupport TypeSupport;
1649  typedef PropertyQosPolicyDataReader DataReader;
1650  typedef PropertyQosPolicyDataWriter DataWriter;
1651  typedef PropertyQosPolicyPtrSeq Seq;
1652 
1653  private:
1654 
1655  }; //DDS::PropertyQosPolicy
1656 
1657  struct Tag;
1658  class TagTypeSupport;
1659  class TagDataReader;
1660  class TagDataWriter;
1661 
1662 /* DDS Data Type SEQUENCE: sequence<DDS::Tag *> */
1663 #ifndef _DDS_sequence_cpp_DDS_TagPtr_defined
1664 #define _DDS_sequence_cpp_DDS_TagPtr_defined
1665  DECLARE_CPP_UNBOUNDED_SEQ( DDS::Tag *, TagPtrSeq );
1666 #endif /* DDS Data Type SEQUENCE: sequence<TagPtrSeq *> */
1667 
1671  struct COREDX_TS_STRUCT_EXPORT Tag {
1672  public:
1674  Tag();
1675  ~Tag();
1676  Tag( const Tag & other );
1677  Tag& operator=( const Tag & other);
1678 
1679  void init();
1680  void clear();
1681  void copy( const DDS::Tag * instance );
1682 
1683  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1684  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1685  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1686  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1687  // deprecated api:
1688  int get_marshal_size( int offset, int just_keys) const;
1689  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1690  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1691 
1693  char * name;
1695  char * value;
1696 
1697  typedef TagTypeSupport TypeSupport;
1698  typedef TagDataReader DataReader;
1699  typedef TagDataWriter DataWriter;
1700  typedef TagPtrSeq Seq;
1701 
1702  private:
1703 
1704  }; //DDS::Tag
1705 
1706 #ifndef _DDS_SEQ_cpp_DDS_DDS_TagSeq_defined
1707 #define _DDS_SEQ_cpp_DDS_DDS_TagSeq_defined
1708  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Tag, DDS_TagSeq );
1709 #endif /* User Defined SEQUENCE: sequence DDS::TagSeq */
1710 
1711  DECLARE_CPP_UNBOUNDED_SEQ( struct DDS::Tag, TagSeq );
1712  struct DataTags;
1713  class DataTagsTypeSupport;
1714  class DataTagsDataReader;
1715  class DataTagsDataWriter;
1716 
1717 /* DDS Data Type SEQUENCE: sequence<DDS::DataTags *> */
1718 #ifndef _DDS_sequence_cpp_DDS_DataTagsPtr_defined
1719 #define _DDS_sequence_cpp_DDS_DataTagsPtr_defined
1720  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DataTags *, DataTagsPtrSeq );
1721 #endif /* DDS Data Type SEQUENCE: sequence<DataTagsPtrSeq *> */
1722 
1726  struct COREDX_TS_STRUCT_EXPORT DataTags {
1727  public:
1729  DataTags();
1730  ~DataTags();
1731  DataTags( const DataTags & other );
1732  DataTags& operator=( const DataTags & other);
1733 
1734  void init();
1735  void clear();
1736  void copy( const DDS::DataTags * instance );
1737 
1738  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1739  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1740  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1741  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1742  // deprecated api:
1743  int get_marshal_size( int offset, int just_keys) const;
1744  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1745  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1746 
1748  DDS::TagSeq tags;
1749 
1750  typedef DataTagsTypeSupport TypeSupport;
1751  typedef DataTagsDataReader DataReader;
1752  typedef DataTagsDataWriter DataWriter;
1753  typedef DataTagsPtrSeq Seq;
1754 
1755  private:
1756 
1757  }; //DDS::DataTags
1758 
1759  typedef struct DDS::DataTags DataTagQosPolicy; /* ns: DDS:: */
1760 
1761  struct DCPSParticipant;
1762  class DCPSParticipantTypeSupport;
1763  class DCPSParticipantDataReader;
1764  class DCPSParticipantDataWriter;
1765 
1766 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSParticipant *> */
1767 #ifndef _DDS_sequence_cpp_DDS_DCPSParticipantPtr_defined
1768 #define _DDS_sequence_cpp_DDS_DCPSParticipantPtr_defined
1769  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSParticipant *, DCPSParticipantPtrSeq );
1770 #endif /* DDS Data Type SEQUENCE: sequence<DCPSParticipantPtrSeq *> */
1771 
1775  struct COREDX_TS_STRUCT_EXPORT DCPSParticipant {
1776  public:
1778  DCPSParticipant();
1779  ~DCPSParticipant();
1780  DCPSParticipant( const DCPSParticipant & other );
1781  DCPSParticipant& operator=( const DCPSParticipant & other);
1782 
1783  void init();
1784  void clear();
1785  void copy( const DDS::DCPSParticipant * instance );
1786 
1787  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1788  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1789  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1790  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1791  // deprecated api:
1792  int get_marshal_size( int offset, int just_keys) const;
1793  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1794  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1795 
1797  struct DDS::BuiltinTopicKey_t key; /* key */
1799  struct DDS::UserDataQosPolicy user_data;
1801  struct DDS::PropertyQosPolicy properties;
1803  char * entity_name;
1804 
1805  typedef DCPSParticipantTypeSupport TypeSupport;
1806  typedef DCPSParticipantDataReader DataReader;
1807  typedef DCPSParticipantDataWriter DataWriter;
1808  typedef DCPSParticipantPtrSeq Seq;
1809 
1810  private:
1811 
1812  }; //DDS::DCPSParticipant
1813 
1814  struct DCPSPublication;
1815  class DCPSPublicationTypeSupport;
1816  class DCPSPublicationDataReader;
1817  class DCPSPublicationDataWriter;
1818 
1819 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSPublication *> */
1820 #ifndef _DDS_sequence_cpp_DDS_DCPSPublicationPtr_defined
1821 #define _DDS_sequence_cpp_DDS_DCPSPublicationPtr_defined
1822  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSPublication *, DCPSPublicationPtrSeq );
1823 #endif /* DDS Data Type SEQUENCE: sequence<DCPSPublicationPtrSeq *> */
1824 
1828  struct COREDX_TS_STRUCT_EXPORT DCPSPublication {
1829  public:
1831  DCPSPublication();
1832  ~DCPSPublication();
1833  DCPSPublication( const DCPSPublication & other );
1834  DCPSPublication& operator=( const DCPSPublication & other);
1835 
1836  void init();
1837  void clear();
1838  void copy( const DDS::DCPSPublication * instance );
1839 
1840  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1841  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1842  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1843  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1844  // deprecated api:
1845  int get_marshal_size( int offset, int just_keys) const;
1846  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1847  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1848 
1850  struct DDS::BuiltinTopicKey_t participant_key;
1852  struct DDS::BuiltinTopicKey_t key; /* key */
1854  char * topic_name;
1856  char * type_name;
1858  struct DDS::DurabilityQosPolicy durability;
1860  struct DDS::DurabilityServiceQosPolicy durability_service;
1862  struct DDS::DeadlineQosPolicy deadline;
1864  struct DDS::LatencyBudgetQosPolicy latency_budget;
1866  struct DDS::LivelinessQosPolicy liveliness;
1868  struct DDS::ReliabilityQosPolicy reliability;
1870  struct DDS::LifespanQosPolicy lifespan;
1872  struct DDS::UserDataQosPolicy user_data;
1874  struct DDS::OwnershipQosPolicy ownership;
1876  struct DDS::OwnershipStrengthQosPolicy ownership_strength;
1878  struct DDS::DestinationOrderQosPolicy destination_order;
1880  struct DDS::PresentationQosPolicy presentation;
1882  struct DDS::PartitionQosPolicy partition;
1884  struct DDS::TopicDataQosPolicy topic_data;
1886  struct DDS::GroupDataQosPolicy group_data;
1888  struct DDS::DataRepresentationQosPolicy representation;
1890  char * entity_name;
1891  struct DDS::TypecodeQosPolicy typecode;
1893  struct DDS::RpcQosPolicy rpc;
1894  DDS::DataTagQosPolicy data_tags;
1895 
1896  typedef DCPSPublicationTypeSupport TypeSupport;
1897  typedef DCPSPublicationDataReader DataReader;
1898  typedef DCPSPublicationDataWriter DataWriter;
1899  typedef DCPSPublicationPtrSeq Seq;
1900 
1901  private:
1902 
1903  }; //DDS::DCPSPublication
1904 
1905  struct DCPSSubscription;
1906  class DCPSSubscriptionTypeSupport;
1907  class DCPSSubscriptionDataReader;
1908  class DCPSSubscriptionDataWriter;
1909 
1910 /* DDS Data Type SEQUENCE: sequence<DDS::DCPSSubscription *> */
1911 #ifndef _DDS_sequence_cpp_DDS_DCPSSubscriptionPtr_defined
1912 #define _DDS_sequence_cpp_DDS_DCPSSubscriptionPtr_defined
1913  DECLARE_CPP_UNBOUNDED_SEQ( DDS::DCPSSubscription *, DCPSSubscriptionPtrSeq );
1914 #endif /* DDS Data Type SEQUENCE: sequence<DCPSSubscriptionPtrSeq *> */
1915 
1919  struct COREDX_TS_STRUCT_EXPORT DCPSSubscription {
1920  public:
1922  DCPSSubscription();
1923  ~DCPSSubscription();
1924  DCPSSubscription( const DCPSSubscription & other );
1925  DCPSSubscription& operator=( const DCPSSubscription & other);
1926 
1927  void init();
1928  void clear();
1929  void copy( const DDS::DCPSSubscription * instance );
1930 
1931  int marshal_cdr( CDX_XcdrBuffer_t *cdr, int just_keys) const ;
1932  int marshal_key_hash( CDX_XcdrBuffer_t * cdr ) const;
1933  int unmarshal_cdr( CDX_XcdrBuffer_t * cdr, int just_keys);
1934  int unmarshal_key_hash( CDX_XcdrBuffer_t * cdr );
1935  // deprecated api:
1936  int get_marshal_size( int offset, int just_keys) const;
1937  int marshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
1938  int unmarshal_cdr( unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
1939 
1941  struct DDS::BuiltinTopicKey_t participant_key;
1943  struct DDS::BuiltinTopicKey_t key; /* key */
1945  char * topic_name;
1947  char * type_name;
1949  struct DDS::DurabilityQosPolicy durability;
1951  struct DDS::DeadlineQosPolicy deadline;
1953  struct DDS::LatencyBudgetQosPolicy latency_budget;
1955  struct DDS::LivelinessQosPolicy liveliness;
1957  struct DDS::ReliabilityQosPolicy reliability;
1959  struct DDS::OwnershipQosPolicy ownership;
1961  struct DDS::DestinationOrderQosPolicy destination_order;
1963  struct DDS::UserDataQosPolicy user_data;
1965  struct DDS::TimeBasedFilterQosPolicy time_based_filter;
1967  struct DDS::PresentationQosPolicy presentation;
1969  struct DDS::PartitionQosPolicy partition;
1971  struct DDS::TopicDataQosPolicy topic_data;
1973  struct DDS::GroupDataQosPolicy group_data;
1975  struct DDS::DataRepresentationQosPolicy representation;
1979  char * entity_name;
1980  struct DDS::TypecodeQosPolicy typecode;
1982  struct DDS::RpcQosPolicy rpc;
1983  DDS::DataTagQosPolicy data_tags;
1984 
1985  typedef DCPSSubscriptionTypeSupport TypeSupport;
1986  typedef DCPSSubscriptionDataReader DataReader;
1987  typedef DCPSSubscriptionDataWriter DataWriter;
1988  typedef DCPSSubscriptionPtrSeq Seq;
1989 
1990  private:
1991 
1992  }; //DDS::DCPSSubscription
1993 
1994 
1995  namespace rpc {
1996 
1997  typedef unsigned char UnknownOperation; /* ns: DDS::rpc:: */
1998 
1999  typedef unsigned char UnknownException; /* ns: DDS::rpc:: */
2000 
2001  typedef unsigned char UnusedMember; /* ns: DDS::rpc:: */
2002 
2003 
2004  } /* namespace rpc */
2005 
2006  } /* namespace DDS */
2007 
2008 #ifdef _MSC_VER
2009 # pragma warning(pop)
2010 #endif
2011 #endif
DataReaders receive data published by the highest strength DataWriter for each Instance.
Definition: dds_builtin.hh:582
OwnershipQosPolicyKind
This enumeration contains the kinds of Ownership.
Definition: dds_builtin.hh:578
Definition: dds_builtin.hh:1919
PresentationQosPolicyAccessScopeKind
This enumeration contains the kinds of Access Scope for the PresentationQosPolicy.
Definition: dds_builtin.hh:390
A name-value pair &#39;tag&#39;.
Definition: dds_builtin.hh:1671
DurabilityQosPolicyKind
This enumeration contains the kinds of Durability.
Definition: dds_builtin.hh:305
Determines instance ownership in the case of multple writers. CoreDX DDS supports both SHARED_OWNERSH...
Definition: dds_builtin.hh:600
Definition: dds_builtin.hh:1828
int32_t history_depth
history depth
Definition: dds_builtin.hh:1244
ReliabilityQosPolicyKind
This enumeration contains the kinds of Reliability.
Definition: dds_builtin.hh:902
Best effort delivery – NO retransmission, HB, or ACKNACK.
Definition: dds_builtin.hh:905
The DurabilityQosPolicy controls the durablity of data.
Definition: dds_builtin.hh:353
Defines the strength, or priority, of a Writer. The strength is used to determine ownership in the ca...
Definition: dds_builtin.hh:652
The scope is within samples published by DataWriters within the Publisher.
Definition: dds_builtin.hh:396
int32_t depth
history depth
Definition: dds_builtin.hh:1111
DataReaders receive data published by multiple DataWriters.
Definition: dds_builtin.hh:580
A hint to the middleware to help configure the transport priority mechanism.
Definition: dds_builtin.hh:217
DDS::DataRepresentationIdSeq value
data representation
Definition: dds_builtin.hh:1318
int32_t max_instances
maximum instances limit for the service
Definition: dds_builtin.hh:1248
Definition: dds_builtin.hh:311
Describes the data representation used by a topic.
Definition: dds_builtin.hh:1296
char * value
the property value
Definition: dds_builtin.hh:1589
int16_t DataRepresentationId_t
Indicates the form of data, for example CDR or XML.
Definition: dds_builtin.hh:1261
Indicates the level of reliability offered/provided by the Entity. If kind is RELIABLE_RELIABILITY_QO...
Definition: dds_builtin.hh:941
Definition: dds_builtin.hh:1218
fixedstring255_t service_instance_name
the name of the service instance
Definition: dds_builtin.hh:1485
int32_t max_instances
maximum instances allowed in the cache
Definition: dds_builtin.hh:1165
The DomainParticipant automatically asserts liveliness for all DataWriters within the DomainParticipa...
Definition: dds_builtin.hh:691
int32_t max_samples_per_instance
maximum samples per instance allowed in the cache
Definition: dds_builtin.hh:1167
char * entity_name
arbitrary string name assigned to participant
Definition: dds_builtin.hh:1803
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:191
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:133
A name-value pair property. The &#39;propagate&#39; flag indicates if this property should be transfered thro...
Definition: dds_builtin.hh:1565
char * topic_name
the topic name
Definition: dds_builtin.hh:1854
DDS::StringSeq topic_aliases
a sequence of aliases to support derived interfaces
Definition: dds_builtin.hh:1489
int32_t max_samples
maximum samples limit for the service
Definition: dds_builtin.hh:1246
DDS::TagSeq tags
a sequence of Tag[s] (name value pairs)
Definition: dds_builtin.hh:1748
Reliable delivery – HB, ACKNACK, and re-transmission.
Definition: dds_builtin.hh:907
char * topic_name
topic name config of this entity
Definition: dds_builtin.hh:1945
Use the reception time to determine the order of samples.
Definition: dds_builtin.hh:982
Definition: dds_builtin_basic.hh:140
DestinationOrderQosPolicyKind
This enumeration contains the kinds of Destination Ordering.
Definition: dds_builtin.hh:980
Typecode representing the datatype a DataReader reads or a DataWriter writes.
Definition: dds_builtin.hh:1404
Specifies allowable latency.
Definition: dds_builtin.hh:541
Definition: dds_builtin.hh:1775
Definition: dds_builtin_basic.hh:41
char * name
the tag &#39;name&#39;
Definition: dds_builtin.hh:1693
Augment a DataWriter or DataReader with RPC specific information.
Definition: dds_builtin.hh:1458
Provides the DDS infrastructure.
Definition: dds_builtin_basic.hh:27
unsigned char ordered_access
Determines if ordered access is supported within the defined &#39;scope&#39;.
Definition: dds_builtin.hh:442
The application manually asserts the liveliness for each individual DataWriter by calling assert_live...
Definition: dds_builtin.hh:695
char * name
the property name
Definition: dds_builtin.hh:1587
Controls the ammount of historical data maintained by a DataReader or DataWriter. ...
Definition: dds_builtin.hh:1087
int32_t value
priority value
Definition: dds_builtin.hh:239
Definition: dds_builtin.hh:313
Defines a logical data partition.
Definition: dds_builtin.hh:864
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:1173
Allows the application to attach arbitrary information to a DomainParticipant, DataWriter or DataRead...
Definition: dds_builtin.hh:54
DDS::OctetSeq value
sequence of bytes
Definition: dds_builtin.hh:76
The scope is within an Instance.
Definition: dds_builtin.hh:392
Store Samples for each Instance (up to the limits specified by ResourceLimitsQosPolicy) until the DDS...
Definition: dds_builtin.hh:1050
Allows the application to attach arbitrary information to a Publisher or Subscriber.
Definition: dds_builtin.hh:169
LivelinessQosPolicyKind
This enumeration contains the kinds of Liveliness.
Definition: dds_builtin.hh:689
rules for determining type consistency
Definition: dds_builtin.hh:1357
char * entity_name
entity name config of this entity
Definition: dds_builtin.hh:1979
char * type_name
type name config of this entity
Definition: dds_builtin.hh:1947
DDS::StringSeq name
sequence of partition names
Definition: dds_builtin.hh:886
Definition: dds_builtin.hh:1624
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:1170
The data is persisted locally within the source DataWriter.
Definition: dds_builtin.hh:309
int32_t max_samples_per_instance
maximum samples per instance limit for the service
Definition: dds_builtin.hh:1250
char * type_name
type of the type
Definition: dds_builtin.hh:1856
The scope is within samples published by DataWriters on the Topic.
Definition: dds_builtin.hh:394
unsigned char coherent_access
Determines if coherent access is supported within the defined &#39;scope&#39;.
Definition: dds_builtin.hh:440
This QoS policy controls how each Subscriber orders received data samples.
Definition: dds_builtin.hh:1008
unsigned char encoding
encoding of the typecode bytes (little endian / big endian
Definition: dds_builtin.hh:1428
unsigned char propagate
propagate over discovery?
Definition: dds_builtin.hh:1591
Store at most depth Samples in the data cache for each Instance. Samples may be overwritten.
Definition: dds_builtin.hh:1047
HistoryQosPolicyKind
This enumeration contains the kinds of History.
Definition: dds_builtin.hh:1045
int32_t max_samples
maximum samples allowed in the cache
Definition: dds_builtin.hh:1163
Controls the presentation of received data samples to the application. CoreDX DDS currently supports ...
Definition: dds_builtin.hh:415
Determines the mechanism and parameters used by the application to determine whether an Entity is ali...
Definition: dds_builtin.hh:737
Allows the application to attach arbitrary information to a Topic QoS.
Definition: dds_builtin.hh:111
TypeConsistencyKind
the allowed kinds of TypeConsistency
Definition: dds_builtin.hh:1333
This QoS policy establishes a minimum update period for data instances.
Definition: dds_builtin.hh:483
The data is volatile, and is not persisted beyond the initial publication.
Definition: dds_builtin.hh:307
Definition: dds_builtin.hh:1335
Specifies the maximum duration of validity of the data written by the DataWriter. ...
Definition: dds_builtin.hh:268
DDS::OctetSeq value
sequence of bytes representing the TypeCode for the data type
Definition: dds_builtin.hh:1426
char * value
the tag &#39;value&#39;
Definition: dds_builtin.hh:1695
A sequence of name-value pair &#39;tags&#39;.
Definition: dds_builtin.hh:1726
Defines a filter based on time between samples. The DataReader indicates that it wants at most one sa...
Definition: dds_builtin.hh:792
Definition: dds_builtin.hh:1337
The Duration_t structure contains data to define a time duration.
Definition: dds_builtin_basic.hh:289
DDS::PropertySeq value
sequence of Property_t&#39;s
Definition: dds_builtin.hh:1646
int32_t value
the ownership strength value
Definition: dds_builtin.hh:674
The application manually asserts the liveliness all DataWriters within this DomainParticipant by call...
Definition: dds_builtin.hh:693
Specifies the resources that the Service can use to maintain data samples and instances.
Definition: dds_builtin.hh:1141
Use the timestamp set by the publisher to determine the order of samples.
Definition: dds_builtin.hh:984

© 2009-2020 Twin Oaks Computing, Inc
Castle Rock, CO 80104
All rights reserved.