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

RTI Connext DDS Micro Version 2.4.9 Copyright © Thu Dec 15 2016 Real-Time Innovations, Inc