RTI Connext DDS Micro  Version 2.4.8
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
reda_sequence_decl.h
1 /*
2  * FILE: reda_sequence_decl.h - Typed Sequence API
3  *
4  * Copyright 2008-2016 Real-Time Innovations, Inc.
5  *
6  * No duplications, whole or partial, manual or electronic, may be made
7  * without express written permission. Any such copies, or
8  * revisions thereof, must display this notice unaltered.
9  * This code contains trade secrets of Real-Time Innovations, Inc.
10  *
11  * Modification History
12  * --------------------
13  * 10feb2016,tk MICRO-1530 Unified REDA_StringSeq, CDR_StringSeq, and DDS_StringSeq
14  * 19may2015,as MICRO-1193 Refactoring of Sequence API levels
15  * 18feb2015,tk Factored out sequence declarations from reda_sequence.h
16  */
17 /*ci
18  * \file
19  *
20  * \brief The REDA Sequence API provides a strongly typed vector API.
21  *
22  * \defgroup REDASequenceClass REDA Sequence
23  * \ingroup REDAModule
24  *
25  * \details
26  *
27  * The REDA sequence API provides a strongly typed API to manage variable
28  * size vectors/arrays of the same type. The typing is achieved by encapsulating
29  * generic function in a typed wrapper using macro's. The documentation
30  * is for the generic functions.
31  */
32 /*ci
33  * \addtogroup REDASequenceClass
34  * @{
35  */
36 #ifndef reda_dll_h
37 #include "reda/reda_dll.h"
38 #endif
39 #ifndef osapi_types_h
40 #include "osapi/osapi_types.h"
41 #endif
42 #include "reda/reda_sequence.h"
43 
44 #if defined(RTI_WIN32) || defined(RTI_WINCE30)
45 #ifdef RTI_EXPORT_REDA_SEQUENCE
46 #ifdef REDADllExport
47 #undef REDADllExport
48 #endif
49 #define REDADllExport __declspec( dllexport )
50 #endif
51 #endif
52 
53 #define concatenate(A, B) A ## B
54 
55 #ifndef T
56 #define T RTI_INT32
57 #endif
58 
59 #ifdef REDA_SEQUENCE_USER_API
60 #ifndef REDA_SEQUENCE_API
61 #define REDA_SEQUENCE_API REDA_SEQUENCE_API_USER_DEFAULT
62 #else
63 #if REDA_SEQUENCE_API < REDA_SEQUENCE_API_BASIC
64 #error "REDA_SEQUENCE_USER_API defined along with API level < REDA_SEQUENCE_API_BASIC"
65 #endif
66 #endif
67 #endif /* REDA_SEQUENCE_USER_API */
68 
69 #ifndef REDA_SEQUENCE_API
70 #define REDA_SEQUENCE_API REDA_SEQUENCE_API_DEFAULT
71 #endif /* REDA_SEQUENCE_API */
72 
73 #if REDA_SEQUENCE_API < REDA_SEQUENCE_API_UNTYPED
74 #error "REDA_SEQUENCE_API_UNTYPED <= REDA_SEQUENCE_API <= REDA_SEQUENCE_API_FULL"
75 #endif
76 
77 /* This corresponds to the BASIC API, the lowest level */
78 #if REDA_SEQUENCE_API > REDA_SEQUENCE_API_UNTYPED
79 #ifndef TSeq_initialize
80 #define TSeq_initialize
81 #endif
82 #ifndef TSeq_get_maximum
83 #define TSeq_get_maximum
84 #endif
85 #ifndef TSeq_set_maximum
86 #define TSeq_set_maximum
87 #endif
88 #ifndef TSeq_get_length
89 #define TSeq_get_length
90 #endif
91 #ifndef TSeq_set_length
92 #define TSeq_set_length
93 #endif
94 #ifndef TSeq_get_reference
95 #define TSeq_get_reference
96 #endif
97 #ifndef RTI_CERT
98 #ifndef TSeq_finalize
99 #define TSeq_finalize
100 #endif
101 #endif /* RTI_CERT */
102 #ifdef REDA_SEQUENCE_USER_API
103 #ifndef TSeq_copy
104 #define TSeq_copy
105 #endif
106 #endif /* REDA_SEQUENCE_USER_API */
107 #endif /* REDA_SEQUENCE_API > REDA_SEQUENCE_API_UNTYPED */
108 
109 /* The FULL API adds the following methods */
110 #if REDA_SEQUENCE_API > REDA_SEQUENCE_API_BASIC
111 #ifndef TSeq_copy
112 #define TSeq_copy
113 #endif
114 #ifndef TSeq_is_equal
115 #define TSeq_is_equal
116 #endif
117 #ifndef TSeq_loan_contiguous
118 #define TSeq_loan_contiguous
119 #endif
120 #ifndef TSeq_loan_discontiguous
121 #define TSeq_loan_discontiguous
122 #endif
123 #ifndef TSeq_has_ownership
124 #define TSeq_has_ownership
125 #endif
126 #ifndef TSeq_has_discontiguous_buffer
127 #define TSeq_has_discontiguous_buffer
128 #endif
129 #ifndef TSeq_get_contiguous_buffer
130 #define TSeq_get_contiguous_buffer
131 #endif
132 #ifndef TSeq_get_discontiguous_buffer
133 #define TSeq_get_discontiguous_buffer
134 #endif
135 #ifndef TSeq_set_contiguous_buffer
136 #define TSeq_set_contiguous_buffer
137 #endif
138 #ifndef TSeq_unloan
139 #define TSeq_unloan
140 #endif
141 #ifndef TSeq_set_token
142 #define TSeq_set_token
143 #endif
144 #ifndef TSeq_get_token
145 #define TSeq_get_token
146 #endif
147 #ifndef TSeq_ensure_length
148 #define TSeq_ensure_length
149 #endif
150 #ifndef TSeq_from_array
151 #define TSeq_from_array
152 #endif
153 #ifndef TSeq_to_array
154 #define TSeq_to_array
155 #endif
156 #endif /* REDA_SEQUENCE_API > REDA_SEQUENCE_API_BASIC */
157 
158 #if REDA_SEQUENCE_API > REDA_SEQUENCE_API_FULL
159 #error "REDA_SEQUENCE_API_UNTYPED <= REDA_SEQUENCE_API <= REDA_SEQUENCE_API_FULL"
160 #endif /* REDA_SEQUENCE_API > REDA_SEQUENCE_API_FULL */
161 
162 /*ci
163  * \addtogroup REDASequenceClass
164  * @{
165  */
166 #ifndef REDA_SEQUENCE_EXCLUDE_STRUCT
167 
168 struct REDADllExport TSeq
169 {
170  T* _contiguous_buffer;
171  RTI_INT32 _maximum;
172  RTI_INT32 _length;
173  RTI_INT32 _element_size;
174  void *_token1;
175  void *_token2;
176  RTI_UINT8 _flags;
177 #ifdef RTI_CPP
178 public:
179 #ifdef TSeq_get_maximum
180  RTI_INT32 maximum() const;
181 #endif
182 #ifdef TSeq_set_maximum
183 #ifndef TSeq_isCDRStringType
184  bool maximum(RTI_INT32 new_max);
185 #else
186 #ifdef TSeq_isCDRStringType_no_max
187  bool maximum(RTI_INT32 new_max,RTI_UINT32 max_str_len);
188 #else
189  bool maximum(RTI_INT32 new_max,RTI_UINT32 max_str_len);
190  bool maximum(RTI_INT32 new_max);
191 #endif
192 #endif
193 #endif
194 #ifdef TSeq_get_length
195  RTI_INT32 length() const;
196 #endif
197 #ifdef TSeq_set_length
198  bool length(RTI_INT32 new_length);
199 #endif
200 #ifdef TSeq_get_reference
201  T* get_reference(RTI_INT32 i);
202 #endif
203 
204 #ifdef TSeq_copy
205 #ifndef TSeq_isCDRStringType
206  bool copy(const TSeq& src_seq);
207 #else
208  bool copy(const TSeq& src_seq,RTI_UINT32 max_str_len);
209  bool copy(const TSeq& src_seq);
210 #endif
211 #endif
212 
213 #ifdef TSeq_is_equal
214  bool is_equal(const TSeq& other) const;
215 #endif
216 #ifdef TSeq_loan_contiguous
217  bool loan_contiguous(void* buffer, RTI_INT32 new_length, RTI_INT32 new_max);
218 #endif
219 #ifdef TSeq_loan_discontiguous
220  bool loan_discontiguous(void* buffer, RTI_INT32 new_length, RTI_INT32 new_max);
221 #endif
222 #ifdef TSeq_unloan
223  bool unloan();
224 #endif
225 #ifdef TSeq_has_ownership
226  bool has_ownership();
227 #endif
228 #ifdef TSeq_get_contiguous_buffer
229  T* get_contiguous_buffer() const;
230 #endif
231 #ifdef TSeq_set_contiguous_buffer
232  bool set_contiguous_buffer(T* buffer);
233 #endif
234 #ifdef TSeq_has_discontiguous_buffer
235  bool has_discontiguous_buffer();
236 #endif
237 #ifdef TSeq_set_token
238  void set_token(void *token1,void *token2);
239 #endif
240 #ifdef TSeq_get_token
241  void get_token(void **token1,void **token2);
242 #endif
243 #ifdef TSeq_ensure_length
244 #ifndef TSeq_isCDRStringType
245  bool ensure_length(RTI_INT32 length, RTI_INT32 max);
246 #else
247 #ifdef TSeq_isCDRStringType_no_max
248  bool ensure_length(RTI_INT32 length, RTI_INT32 max,RTI_UINT32 max_str_len);
249 #else
250  bool ensure_length(RTI_INT32 length, RTI_INT32 max,RTI_UINT32 max_str_len);
251  bool ensure_length(RTI_INT32 length, RTI_INT32 max);
252 #endif
253 #endif
254 #endif
255 
256 #ifdef TSeq_from_array
257 #ifndef TSeq_isCDRStringType
258  bool from_array(const T elv[], RTI_INT32 length);
259 #else
260 #ifdef TSeq_isCDRStringType_no_max
261  bool from_array(const T elv[], RTI_INT32 length,RTI_UINT32 max_str_len);
262 #else
263  bool from_array(const T elv[], RTI_INT32 length,RTI_UINT32 max_str_len);
264  bool from_array(const T elv[], RTI_INT32 length);
265 #endif
266 #endif
267 #endif
268 
269 #ifdef TSeq_to_array
270 #ifndef TSeq_isCDRStringType
271  bool to_array(T elv[], RTI_INT32 length);
272 #else
273 #ifdef TSeq_isCDRStringType_no_max
274  bool to_array(T elv[], RTI_INT32 length,RTI_UINT32 max_str_len);
275 #else
276  bool to_array(T elv[], RTI_INT32 length,RTI_UINT32 max_str_len);
277  bool to_array(T elv[], RTI_INT32 length);
278 #endif
279 #endif
280 #endif
281  TSeq();
282  ~TSeq();
283 
284 #ifdef RTI_CERT
285 private:
286 #else
287 public:
288 #endif /* RTI_CERT */
289  TSeq(const TSeq& seq);
290 #ifdef TSeq_copy
291  TSeq& operator=(const TSeq& src_seq);
292 #endif
293 #ifdef TSeq_get_reference
294  T& operator[] (RTI_INT32 index);
295  const T& operator[] (RTI_INT32 index) const;
296 #endif
297 #ifdef TSeq_is_equal
298  bool operator==(const TSeq& other) const;
299  bool operator!=(const TSeq& other) const;
300 #endif
301 
302 #endif /* RTI_CPP */
303 };
304 
305 /* REDA_DEFINE_SEQUENCE_OVERLOADED_METHODS(TSeq,T) */
306 
307 #if REDA_SEQUENCE_API > REDA_SEQUENCE_API_FULL
308 #error "REDA_SEQUENCE_API_UNTYPED <= REDA_SEQUENCE_API <= REDA_SEQUENCE_API_FULL"
309 #endif
310 #endif /* REDA_SEQUENCE_EXCLUDE_STRUCT */
311 
312 #ifndef REDA_SEQUENCE_EXCLUDE_C_METHODS
313 #ifdef __cplusplus
314 extern "C"
315 {
316 #endif
317 
318 #ifdef TSeq_initialize
319 #undef TSeq_initialize
320 #define _initialize(TSeq) concatenate(TSeq, _initialize)
321 #define TSeq_initialize _initialize(TSeq)
322 /*ci
323  * \brief Initialize a sequence of type T
324  *
325  * \details
326  *
327  * Initializes a sequence structure TSeq based on the element size of
328  * sequence type T. The initialization may call a type specific T_initialize
329  * for each element type T if it is defined.
330  *
331  * \return RTI_TRUE on success, RTI_FALSE on failure
332  *
333  * \param[in] self Sequence structure to initialize
334  *
335  * \sa TSeq_finalize
336  */
337 REDADllExport RTI_BOOL
338 TSeq_initialize(struct TSeq* self);
339 #undef _initialize
340 #undef TSeq_initialize
341 #endif
342 
343 #ifdef TSeq_finalize
344 #undef TSeq_finalize
345 #define _finalize(TSeq) concatenate(TSeq, _finalize)
346 #define TSeq_finalize _finalize(TSeq)
347 /*ci
348  * \brief Finalize a sequence of type T
349  *
350  * \details
351  *
352  * Finalizes a sequence TSeq based and releases all memory allocated to it.
353  * Each sequence element may be finalized individually if T_finalize is defined
354  * for the sequence type.
355  *
356  * \return RTI_TRUE on success, RTI_FALSE on failure
357  *
358  * \param[in] self Sequence structure to finalize
359  *
360  * \sa TSeq_finalize
361  */
362 REDADllExport RTI_BOOL
363 TSeq_finalize(struct TSeq *self);
364 #undef _finalize
365 #undef TSeq_finalize
366 #endif
367 
368 #ifdef TSeq_get_maximum
369 #undef TSeq_get_maximum
370 #define _get_maximum(TSeq) concatenate(TSeq, _get_maximum)
371 #define TSeq_get_maximum _get_maximum(TSeq)
372 REDADllExport RTI_INT32
373 TSeq_get_maximum(const struct TSeq *self);
374 #undef _get_maximum
375 #undef TSeq_get_maximum
376 #endif
377 
378 #ifdef TSeq_set_maximum
379 #undef TSeq_set_maximum
380 #define _set_maximum(TSeq) concatenate(TSeq, _set_maximum)
381 #define TSeq_set_maximum _set_maximum(TSeq)
382 #ifndef TSeq_isCDRStringType
383 REDADllExport RTI_BOOL
384 TSeq_set_maximum(struct TSeq *self, RTI_INT32 new_max);
385 #else
386 #ifdef TSeq_isCDRStringType_no_max
387 REDADllExport RTI_BOOL
388 TSeq_set_maximum(struct TSeq *self, RTI_INT32 new_max, RTI_UINT32 max_str_len);
389 #else
390 #undef TSeq_set_maximum_w_max
391 #define _set_maximum_w_max(TSeq) concatenate(TSeq,_set_maximum_w_max)
392 #define TSeq_set_maximum_w_max _set_maximum_w_max(TSeq)
393 REDADllExport RTI_BOOL
394 TSeq_set_maximum_w_max(struct TSeq *self, RTI_INT32 new_max, RTI_UINT32 max_str_len);
395 
396 REDADllExport RTI_BOOL
397 TSeq_set_maximum(struct TSeq *self, RTI_INT32 new_max);
398 #endif
399 #endif
400 #undef _set_maximum
401 #undef TSeq_set_maximum
402 #undef _set_maximum_w_max
403 #undef TSeq_set_maximum_w_max
404 #endif
405 
406 #ifdef TSeq_get_length
407 #undef TSeq_get_length
408 #define _get_length(TSeq) concatenate(TSeq, _get_length)
409 #define TSeq_get_length _get_length(TSeq)
410 REDADllExport RTI_INT32
411 TSeq_get_length(const struct TSeq *self);
412 #undef _get_length
413 #undef TSeq_get_length
414 #endif
415 
416 #ifdef TSeq_set_length
417 #undef TSeq_set_length
418 #define _set_length(TSeq) concatenate(TSeq, _set_length)
419 #define TSeq_set_length _set_length(TSeq)
420 REDADllExport RTI_BOOL
421 TSeq_set_length(struct TSeq *self, RTI_INT32 new_length);
422 #undef _set_length
423 #undef TSeq_set_length
424 #endif
425 
426 #ifdef TSeq_get_reference
427 #undef TSeq_get_reference
428 #define _get_reference(TSeq) concatenate(TSeq, _get_reference)
429 #define TSeq_get_reference _get_reference(TSeq)
430 REDADllExport T*
431 TSeq_get_reference(const struct TSeq *self, RTI_INT32 i);
432 #undef _get_reference
433 #undef TSeq_get_reference
434 #endif
435 
436 #ifdef TSeq_copy
437 #undef TSeq_copy
438 #define _copy(TSeq) concatenate(TSeq, _copy)
439 #define TSeq_copy _copy(TSeq)
440 #ifndef TSeq_isCDRStringType
441 REDADllExport struct TSeq*
442 TSeq_copy(struct TSeq *self, const struct TSeq *src);
443 #else
444 #ifdef TSeq_isCDRStringType_no_max
445 REDADllExport struct TSeq*
446 TSeq_copy(struct TSeq *self, const struct TSeq *src, RTI_UINT32 max_str_len);
447 #else
448 #undef TSeq_copy_w_max
449 #define _copy_w_max(TSeq) concatenate(TSeq, _copy_w_max)
450 #define TSeq_copy_w_max _copy_w_max(TSeq)
451 REDADllExport struct TSeq*
452 TSeq_copy_w_max(struct TSeq *self, const struct TSeq *src, RTI_UINT32 max_str_len);
453 
454 REDADllExport struct TSeq*
455 TSeq_copy(struct TSeq *self, const struct TSeq *src);
456 #endif
457 #endif
458 #undef _copy
459 #undef TSeq_copy
460 #undef _copy_w_max
461 #undef TSeq_copy_w_max
462 #endif
463 
464 #ifdef TSeq_is_equal
465 #undef TSeq_is_equal
466 #define _is_equal(TSeq) concatenate(TSeq, _is_equal)
467 #define TSeq_is_equal _is_equal(TSeq)
468 REDADllExport RTI_BOOL
469 TSeq_is_equal(const struct TSeq *left, const struct TSeq *right);
470 #undef _is_equal
471 #undef TSeq_is_equal
472 #endif
473 
474 #ifdef TSeq_loan_contiguous
475 #undef TSeq_loan_contiguous
476 #define _loan_contiguous(TSeq) concatenate(TSeq, _loan_contiguous)
477 #define TSeq_loan_contiguous _loan_contiguous(TSeq)
478 REDADllExport RTI_BOOL
479 TSeq_loan_contiguous(struct TSeq *self, void *buffer,
480  RTI_INT32 new_length, RTI_INT32 new_max);
481 #undef _loan_contiguous
482 #undef TSeq_loan_contiguous
483 #endif
484 
485 #ifdef TSeq_loan_discontiguous
486 #undef TSeq_loan_discontiguous
487 #define _loan_discontiguous(TSeq) concatenate(TSeq, _loan_discontiguous)
488 #define TSeq_loan_discontiguous _loan_discontiguous(TSeq)
489 REDADllExport RTI_BOOL
490 TSeq_loan_discontiguous(struct TSeq *self, void *buffer,
491  RTI_INT32 new_length, RTI_INT32 new_max);
492 #undef _loan_discontiguous
493 #undef TSeq_loan_discontiguous
494 #endif /* TSeq_loan_discontiguous */
495 
496 #ifdef TSeq_unloan
497 #undef TSeq_unloan
498 #define _unloan(TSeq) concatenate(TSeq, _unloan)
499 #define TSeq_unloan _unloan(TSeq)
500 REDADllExport RTI_BOOL
501 TSeq_unloan(struct TSeq *self);
502 #undef _unloan
503 #undef TSeq_unloan
504 #endif /* TSeq_unloan */
505 
506 #ifdef TSeq_has_ownership
507 #undef TSeq_has_ownership
508 #define _has_ownership(TSeq) concatenate(TSeq, _has_ownership)
509 #define TSeq_has_ownership _has_ownership(TSeq)
510 REDADllExport RTI_BOOL
511 TSeq_has_ownership(const struct TSeq *self);
512 #undef _has_ownership
513 #undef TSeq_has_ownership
514 #endif /* TSeq_has_ownership */
515 
516 #ifdef TSeq_get_contiguous_buffer
517 #undef TSeq_get_contiguous_buffer
518 #define _get_contiguous_buffer(TSeq) concatenate(TSeq, _get_contiguous_buffer)
519 #define TSeq_get_contiguous_buffer _get_contiguous_buffer(TSeq)
520 REDADllExport T*
521 TSeq_get_contiguous_buffer(const struct TSeq *self);
522 #undef _get_contiguous_buffer
523 #undef TSeq_get_contiguous_buffer
524 #endif /* TSeq_get_buffer */
525 
526 #ifdef TSeq_get_discontiguous_buffer
527 #undef TSeq_get_discontiguous_buffer
528 #define _get_discontiguous_buffer(TSeq) concatenate(TSeq, TSeq_get_discontiguous_buffer)
529 #define TSeq_get_discontiguous_buffer _get_discontiguous_buffer(TSeq)
530 REDADllExport T*
531 TSeq_get_discontiguous_buffer(const struct TSeq *self);
532 #undef _get_discontiguous_buffer
533 #undef TSeq_get_discontiguous_buffer
534 #endif /* TSeq_get_discontiguous_buffer */
535 
536 #ifdef TSeq_set_contiguous_buffer
537 #undef TSeq_set_contiguous_buffer
538 #define _set_contiguous_buffer(TSeq) concatenate(TSeq, _set_contiguous_buffer)
539 #define TSeq_set_contiguous_buffer _set_contiguous_buffer(TSeq)
540 REDADllExport RTI_BOOL
541 TSeq_set_contiguous_buffer(struct TSeq *self, T *buffer);
542 #undef _set_contiguous_buffer
543 #undef TSeq_set_contiguous_buffer
544 #endif /* TSeq_set_buffer */
545 
546 #ifdef TSeq_has_discontiguous_buffer
547 #undef TSeq_has_discontiguous_buffer
548 #define _has_discontiguous_buffer(TSeq) concatenate(TSeq, _has_discontiguous_buffer)
549 #define TSeq_has_discontiguous_buffer _has_discontiguous_buffer(TSeq)
550 REDADllExport RTI_BOOL
551 TSeq_has_discontiguous_buffer(const struct TSeq *self);
552 #undef _has_discontiguous_buffer
553 #undef TSeq_has_discontiguous_buffer
554 #endif /* TSeq_has_discontiguous_buffer */
555 
556 #ifdef TSeq_set_token
557 #undef TSeq_set_token
558 #define _set_token(TSeq) concatenate(TSeq, _set_token)
559 #define TSeq_set_token _set_token(TSeq)
560 REDADllExport void
561 TSeq_set_token(struct TSeq *self,void *token1,void *token2);
562 #undef _set_token
563 #undef TSeq_set_token
564 #endif /* TSeq_set_token */
565 
566 #ifdef TSeq_get_token
567 #undef TSeq_get_token
568 #define _get_token(TSeq) concatenate(TSeq, _get_token)
569 #define TSeq_get_token _get_token(TSeq)
570 REDADllExport void
571 TSeq_get_token(struct TSeq *self,void **token1,void **token2);
572 #undef _get_token
573 #undef TSeq_get_token
574 #endif /* TSeq_get_token */
575 
576 #ifdef TSeq_ensure_length
577 #undef TSeq_ensure_length
578 #define _ensure_length(TSeq) concatenate(TSeq, _ensure_length)
579 #define TSeq_ensure_length _ensure_length(TSeq)
580 #ifndef TSeq_isCDRStringType
581 REDADllExport RTI_BOOL
582 TSeq_ensure_length(struct TSeq *self,RTI_INT32 length, RTI_INT32 max);
583 #else
584 #ifdef TSeq_isCDRStringType_no_max
585 REDADllExport RTI_BOOL
586 TSeq_ensure_length(struct TSeq *self,RTI_INT32 length, RTI_INT32 max,
587  RTI_INT32 max_str_len);
588 #else
589 #undef TSeq_ensure_length_w_max
590 #define _ensure_length_w_max(TSeq) concatenate(TSeq, _ensure_length_w_max)
591 #define TSeq_ensure_length_w_max _ensure_length_w_max(TSeq)
592 REDADllExport RTI_BOOL
593 TSeq_ensure_length_w_max(struct TSeq *self,RTI_INT32 length, RTI_INT32 max,
594  RTI_INT32 max_str_len);
595 REDADllExport RTI_BOOL
596 TSeq_ensure_length(struct TSeq *self,RTI_INT32 length, RTI_INT32 max);
597 #endif
598 #endif
599 #undef _ensure_length
600 #undef TSeq_ensure_length
601 #undef _ensure_length_w_max
602 #undef TSeq_ensure_length_max
603 #endif /* TSeq_ensure_length */
604 
605 #ifdef TSeq_from_array
606 #undef TSeq_from_array
607 #define _from_array(TSeq) concatenate(TSeq, _from_array)
608 #define TSeq_from_array _from_array(TSeq)
609 #ifndef TSeq_isCDRStringType
610 REDADllExport RTI_BOOL
611 TSeq_from_array(struct TSeq *self, const T elms_seq[], RTI_INT32 length);
612 #else
613 #ifdef TSeq_isCDRStringType_no_max
614 REDADllExport RTI_BOOL
615 TSeq_from_array(struct TSeq *self, const T elms_seq[], RTI_INT32 length,RTI_INT32 max_str_len);
616 #else
617 #undef TSeq_from_array_w_max
618 #define _from_array_w_max(TSeq) concatenate(TSeq, _from_array_w_max)
619 #define TSeq_from_array_w_max _from_array_w_max(TSeq)
620 REDADllExport RTI_BOOL
621 TSeq_from_array_w_max(struct TSeq *self, const T elms_seq[], RTI_INT32 length,RTI_INT32 max_str_len);
622 
623 REDADllExport RTI_BOOL
624 TSeq_from_array(struct TSeq *self, const T elms_seq[], RTI_INT32 length);
625 #endif
626 #endif
627 #undef _from_array
628 #undef TSeq_from_array
629 #undef _from_array_w_max
630 #undef TSeq_from_array_w_max
631 #endif /* TSeq_from_array */
632 
633 #ifdef TSeq_to_array
634 #undef TSeq_to_array
635 #define _to_array(TSeq) concatenate(TSeq, _to_array)
636 #define TSeq_to_array _to_array(TSeq)
637 #ifndef TSeq_isCDRStringType
638 REDADllExport RTI_BOOL
639 TSeq_to_array(struct TSeq *self,T elms_seq[], RTI_INT32 length);
640 #else
641 #ifdef TSeq_isCDRStringType_no_max
642 REDADllExport RTI_BOOL
643 TSeq_to_array(struct TSeq *self,T elms_seq[], RTI_INT32 length,RTI_INT32 max_str_len);
644 #else
645 #undef TSeq_to_array_w_max
646 #define _to_array_w_max(TSeq) concatenate(TSeq, _to_array_w_max)
647 #define TSeq_to_array_w_max _to_array_w_max(TSeq)
648 REDADllExport RTI_BOOL
649 TSeq_to_array_w_max(struct TSeq *self,T elms_seq[], RTI_INT32 length,RTI_INT32 max_str_len);
650 
651 REDADllExport RTI_BOOL
652 TSeq_to_array(struct TSeq *self,T elms_seq[], RTI_INT32 length);
653 #endif
654 #endif
655 #undef _to_array
656 #undef TSeq_to_array
657 #undef _to_array_w_max
658 #undef TSeq_to_array_max
659 #endif /* TSeq_to_array */
660 
661 #ifdef __cplusplus
662 } /* extern "C" */
663 #endif
664 
665 #endif /* REDA_SEQUENCE_EXCLUDE_C_METHODS */
666 
667 #undef TSeq
668 #undef T
669 #undef REDA_SEQUENCE_API
670 #undef concatenate
671 #undef TSeq_isCDRStringType
672 #undef TSeq_isCDRStringType_no_max
673 #undef TSeq_isCDRCharStringType
674 #undef REDA_SEQUENCE_EXCLUDE_STRUCT
675 #undef REDA_SEQUENCE_EXCLUDE_C_METHODS
676 #undef REDA_SEQUENCE_USER_API
677 
678 /*ci @} */

RTI Connext DDS Micro Version 2.4.8 Copyright © Tue Apr 12 2016 Real-Time Innovations, Inc