RTI Connext DDS Micro  Version 2.4.11
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cdr_serialize.h
1 /*
2  * FILE: cdr_serialize.h - CDR serialize API
3  *
4  * (c) Copyright, Real-Time Innovations, 2012-2015.
5  * All rights reserved.
6  *
7  * No duplications, whole or partial, manual or electronic, may be made
8  * without express written permission. Any such copies, or
9  * revisions thereof, must display this notice unaltered.
10  * This code contains trade secrets of Real-Time Innovations, Inc.
11  *
12  * Modification History
13  * --------------------
14  * 30jun2015,eh MICRO-1374/PR#15168 Rename CDR_Stream_has_free_space to
15  * CDR_Stream_has_remaining_space
16  * 09jun2015,eh MICRO-1296/PR#14964 Make non-private CDR_Stream_has_free_space
17  * 23feb2015,eh MICRO-1075: remove and replace macros
18  * 15sep2014,eh Updated documentation
19  * 24mar2012,kaj Written
20  */
21 
22 /*ci
23  * \file
24  * \defgroup CDRSerializeClass CDR Serialize
25  * \ingroup CDRModule
26  * \brief Serialization to and deserialization from CDR streams
27  *
28  * \details
29  * Operations to serialize types, and sequences and arrays of types,
30  * into CDR streams.
31  * Operations to deserialize types, and sequences and arrays of types,
32  * from CDR streams.
33  * Operations to get sizes of serialized types in CDR streams.
34  */
35 
36 /*ci \addtogroup CDRSerializeClass
37  * @{
38  */
39 #ifndef cdr_serialize_h
40 #define cdr_serialize_h
41 
42 #ifndef reda_sequence_h
43 #include "reda/reda_sequence.h"
44 #endif
45 #ifndef reda_sequenceNumber_h
46 #include "reda/reda_sequenceNumber.h"
47 #endif
48 #ifndef cdr_dll_h
49 #include "cdr/cdr_dll.h"
50 #endif
51 #ifndef cdr_cdr_type_h
52 #include "cdr/cdr_cdr_type.h"
53 #endif
54 #ifndef cdr_stream_h
55 #include "cdr/cdr_stream.h"
56 #endif
57 #ifndef cdr_serialize_impl_h
58 #include "cdr/cdr_serialize_impl.h"
59 #endif
60 
61 #ifdef __cplusplus
62 extern "C"
63 {
64 #endif
65 
66 /*ci \brief Standard CDR serialized parameter alignment */
67 #define CDR_DEFAULT_PARAMETER_ALIGNMENT (4)
68 
69 /*ci \brief Get max serialized size of octet */
70 #define CDR_get_max_size_serialized_octet CDR_get_1_byte_max_size_serialized
71 
72 /*ci \brief Get max serialized size of char */
73 #define CDR_get_max_size_serialized_char CDR_get_1_byte_max_size_serialized
74 
75 /*ci \brief Get max serialized size of boolean */
76 #define CDR_get_max_size_serialized_boolean CDR_get_1_byte_max_size_serialized
77 
78 /*ci \brief Get max serialized size of short */
79 #define CDR_get_max_size_serialized_short CDR_get_2_byte_max_size_serialized
80 
81 /*ci \brief Get max serialized size of unsigned short */
82 #define CDR_get_max_size_serialized_unsigned_short \
83  CDR_get_2_byte_max_size_serialized
84 
85 /*ci \brief Get max serialized size of long */
86 #define CDR_get_max_size_serialized_long CDR_get_4_byte_max_size_serialized
87 
88 /*ci \brief Get max serialized size of unsigned long */
89 #define CDR_get_max_size_serialized_unsigned_long \
90  CDR_get_4_byte_max_size_serialized
91 
92 /*ci \brief Get max serialized size of wchar */
93 #define CDR_get_max_size_serialized_wchar CDR_get_4_byte_max_size_serialized
94 
95 /*ci \brief Get max serialized size of enum */
96 #define CDR_get_max_size_serialized_enum CDR_get_4_byte_max_size_serialized
97 
98 /*ci \brief Get max serialized size of float */
99 #define CDR_get_max_size_serialized_float CDR_get_4_byte_max_size_serialized
100 
101 /*ci \brief Get max serialized size of long long */
102 #define CDR_get_max_size_serialized_long_long CDR_get_8_byte_max_size_serialized
103 
104 /*ci \brief Get max serialized size of unsigned long long */
105 #define CDR_get_max_size_serialized_unsigned_long_long \
106  CDR_get_8_byte_max_size_serialized
107 
108 /*ci \brief Get max serialized size of double */
109 #define CDR_get_max_size_serialized_double CDR_get_8_byte_max_size_serialized
110 
111 /*ci \brief Get max serialized size of long double */
112 #define CDR_get_max_size_serialized_long_double CDR_get_16_byte_max_size_serialized
113 
114 /*******************************************************************************
115  * Declare serialization / deserialization for base primative types:
116  * UnsignedShort (2 bytes), UnsignedLong (4 bytes), UnsignedLongLong (8 bytes),
117  * LongDouble (16 bytes)
118  ******************************************************************************/
119 
120 /*ci
121  * \brief
122  * Serialize an unsigned short
123  *
124  * \param[in] dest_buffer Serialization buffer
125  * \param[in] instance Value to serialize
126  * \param[in] byte_swap Flag whether to byte swap when serializing
127  *
128  */
129 CDRDllExport void
130 CDR_serialize_unsigned_short(char **dest_buffer, const RTI_UINT16 * instance,
131  RTI_BOOL byte_swap);
132 
133 /*ci
134  * \brief
135  * Deserialize an unsigned short
136  *
137  * \param[in] src_buffer Deserialization buffer
138  * \param[out] instance Deserialized instance
139  * \param[in] byte_swap Flag whether to byte swap when deserializing
140  *
141  */
142 CDRDllExport void
143 CDR_deserialize_unsigned_short(char **src_buffer, RTI_UINT16 * instance,
144  RTI_BOOL byte_swap);
145 
146 /*ci
147  * \brief
148  * Deserialize an unsigned short from big endian byte order
149  *
150  * \param[in] src_buffer Deserialization buffer
151  * \param[out] instance Deserialized instance
152  *
153  */
154 CDRDllExport void
155 CDR_deserialize_unsigned_short_from_big_endian(char **src_buffer,
156  RTI_UINT16 * instance);
157 
158 /*ci
159  * \brief
160  * Serialize an unsigned long
161  *
162  * \param[in] dest_buffer Serialization buffer
163  * \param[in] instance Value to serialize
164  * \param[in] byte_swap Flag whether to byte swap when serializing
165  *
166  */
167 CDRDllExport void
168 CDR_serialize_unsigned_long(char **dest_buffer, const RTI_UINT32 * instance,
169  RTI_BOOL byte_swap);
170 
171 /*ci
172  * \brief
173  * Deserialize an unsigned long
174  *
175  * \param[in] src_buffer Deserialization buffer
176  * \param[out] instance Deserialized instance
177  * \param[in] byte_swap Flag whether to byte swap when deserializing
178  *
179  */
180 CDRDllExport void
181 CDR_deserialize_unsigned_long(char **src_buffer, RTI_UINT32 * instance,
182  RTI_BOOL byte_swap);
183 
184 /*ci
185  * \brief
186  * Serialize an unsigned long to big endian byte order
187  *
188  * \param[in] dest_buffer Serialization buffer
189  * \param[in] instance Value to serialize
190  *
191  */
192 CDRDllExport void
193 CDR_serialize_unsigned_long_to_big_endian(char **dest_buffer,
194  const RTI_UINT32 * instance);
195 
196 /*ci
197  * \brief
198  * Deserialize an unsigned long from big endian byte order
199  *
200  * \param[in] src_buffer Deserialization buffer
201  * \param[out] instance Deserialized instance
202  *
203  */
204 CDRDllExport void
205 CDR_deserialize_unsigned_long_from_big_endian(char **src_buffer,
206  RTI_UINT32 * instance);
207 
208 /*ci
209  * \brief
210  * Serialize an unsigned long long
211  *
212  * \param[in] dest_buffer Serialization buffer
213  * \param[in] instance Value to serialize
214  * \param[in] byte_swap Flag whether to byte swap when serializing
215  *
216  */
217 CDRDllExport void
218 CDR_serialize_unsigned_long_long(char **dest_buffer, const RTI_UINT64 * instance,
219  RTI_BOOL byte_swap);
220 
221 /*ci
222  * \brief
223  * Deserialize an unsigned long long
224  *
225  * \param[in] src_buffer Deserialization buffer
226  * \param[out] instance Deserialized instance
227  * \param[in] byte_swap Flag whether to byte swap when deserializing
228  *
229  */
230 CDRDllExport void
231 CDR_deserialize_unsigned_long_long(char **src_buffer, RTI_UINT64 * instance,
232  RTI_BOOL byte_swap);
233 
234 /*ci
235  * \brief
236  * Serialize a long double
237  *
238  * \param[in] dest_buffer Serialization buffer
239  * \param[in] instance Value to serialize
240  * \param[in] byte_swap Flag whether to byte swap when serializing
241  *
242  */
243 CDRDllExport void
244 CDR_serialize_long_double(char **dest_buffer, const RTI_DOUBLE128 * instance,
245  RTI_BOOL byte_swap);
246 
247 /*ci
248  * \brief
249  * Deserialize a long double
250  *
251  * \param[in] src_buffer Deserialization buffer
252  * \param[out] instance Deserialized instance
253  * \param[in] byte_swap Flag whether to byte swap when deserializing
254  *
255  */
256 CDRDllExport void
257 CDR_deserialize_long_double(char **src_buffer, RTI_DOUBLE128 * instance,
258  RTI_BOOL byte_swap);
259 
260 /******************************************************************************
261  * Define serialization / deserialization macros for primative types that are
262  * implemented by equivalent sized base primative types
263  ******************************************************************************/
264 
265 /*ci \brief Deserialize Long */
266 #define CDR_deserialize_long(__buf,__inst,_b) \
267  CDR_deserialize_unsigned_long(__buf,((RTI_UINT32*)__inst),_b)
268 
269 /*******************************************************************************
270  * Declare stream serialization / deserialization for base primative types:
271  * Char (1 byte), UnsignedShort (2 bytes), UnsignedLong (4 bytes),
272  * UnsignedLongLong (8 bytes), LongDouble (16 bytes)
273  ******************************************************************************/
274 
275 /*ci
276  * \brief
277  * Serialize a char with a stream
278  *
279  * \param[in] cdrs Serialization stream
280  * \param[in] instance Value to serialize
281  *
282  * \return RTI_TRUE on success, RTI_FALSE on failure
283  */
284 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
285 CDR_Stream_serialize_char(struct CDR_Stream_t *cdrs, const RTI_INT8 * instance);
286 
287 /*ci
288  * \brief
289  * Deserialize a char with a stream
290  *
291  * \param[in] cdrs Deserialization buffer
292  * \param[out] instance Deserialized instance
293  *
294  * \return RTI_TRUE on success, RTI_FALSE on failure
295  */
296 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
297 CDR_Stream_deserialize_char(struct CDR_Stream_t *cdrs, RTI_INT8 * instance);
298 
299 /*ci
300  * \brief
301  * Serialize an unsigned short with a CDR stream
302  *
303  * \param[in] cdrs Serialization stream
304  * \param[in] instance Value to serialize
305  *
306  * \return RTI_TRUE on success, RTI_FALSE on failure
307  */
308 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
309 CDR_Stream_serialize_unsigned_short(struct CDR_Stream_t *cdrs,
310  const RTI_UINT16 * instance);
311 
312 /*ci
313  * \brief
314  * Deserialize an unsigned short with a stream
315  *
316  * \param[in] cdrs Deserialization buffer
317  * \param[out] instance Deserialized instance
318  *
319  * \return RTI_TRUE on success, RTI_FALSE on failure
320  */
321 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
322 CDR_Stream_deserialize_unsigned_short(struct CDR_Stream_t *cdrs,
323  RTI_UINT16 * instance);
324 
325 /*ci
326  * \brief
327  * Serialize an unsigned short to big endian byte order with a CDR stream
328  *
329  * \param[in] cdrs Serialization stream
330  * \param[in] instance Value to serialize
331  *
332  * \return RTI_TRUE on success, RTI_FALSE on failure
333  */
334 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
335 CDR_Stream_serialize_unsigned_short_to_big_endian(struct CDR_Stream_t *cdrs,
336  const RTI_UINT16 * instance);
337 
338 /*ci
339  * \brief
340  * Deserialize an unsigned short of big endian byte order with a stream
341  *
342  * \param[in] cdrs Deserialization buffer
343  * \param[out] instance Deserialized instance
344  *
345  * \return RTI_TRUE on success, RTI_FALSE on failure
346  */
347 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
348 CDR_Stream_deserialize_unsigned_short_from_big_endian(struct CDR_Stream_t *cdrs,
349  RTI_UINT16* instance);
350 
351 /*ci
352  * \brief
353  * Serialize an unsigned long with a CDR stream
354  *
355  * \param[in] cdrs Serialization stream
356  * \param[in] instance Value to serialize
357  *
358  * \return RTI_TRUE on success, RTI_FALSE on failure
359  */
360 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
361 CDR_Stream_serialize_unsigned_long(struct CDR_Stream_t *cdrs,
362  const RTI_UINT32 * instance);
363 
364 /*ci
365  * \brief
366  * Deserialize an unsigned long with a stream
367  *
368  * \param[in] cdrs Deserialization buffer
369  * \param[out] instance Deserialized instance
370  *
371  * \return RTI_TRUE on success, RTI_FALSE on failure
372  */
373 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
374 CDR_Stream_deserialize_unsigned_long(struct CDR_Stream_t *cdrs,
375  RTI_UINT32 * instance);
376 
377 /*ci
378  * \brief
379  * Serialize an unsigned long to big endian byte order with a CDR stream
380  *
381  * \param[in] cdrs Serialization stream
382  * \param[in] instance Value to serialize
383  *
384  * \return RTI_TRUE on success, RTI_FALSE on failure
385  */
386 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
387 CDR_Stream_serialize_unsigned_long_to_big_endian(struct CDR_Stream_t *cdrs,
388  const RTI_UINT32 * instance);
389 
390 /*ci
391  * \brief
392  * Deserialize an unsigned long with big endian byte order from a stream
393  *
394  * \param[in] cdrs Deserialization buffer
395  * \param[out] instance Deserialized instance
396  *
397  * \return RTI_TRUE on success, RTI_FALSE on failure
398  */
399 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
400 CDR_Stream_deserialize_unsigned_long_from_big_endian(struct CDR_Stream_t *cdrs,
401  RTI_UINT32 * instance);
402 
403 /*ci
404  * \brief
405  * Serialize an unsigned long long with a CDR stream
406  *
407  * \param[in] cdrs Serialization stream
408  * \param[in] instance Value to serialize
409  *
410  * \return RTI_TRUE on success, RTI_FALSE on failure
411  */
412 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
413 CDR_Stream_serialize_unsigned_long_long(struct CDR_Stream_t *cdrs,
414  const RTI_UINT64 * instance);
415 
416 /*ci
417  * \brief
418  * Deserialize an unsigned long long from a stream
419  *
420  * \param[in] cdrs Deserialization buffer
421  * \param[out] instance Deserialized instance
422  *
423  * \return RTI_TRUE on success, RTI_FALSE on failure
424  */
425 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
426 CDR_Stream_deserialize_unsigned_long_long(struct CDR_Stream_t *cdrs,
427  RTI_UINT64 * instance);
428 
429 /*ci
430  * \brief
431  * Serialize a long double with a CDR stream
432  *
433  * \param[in] cdrs Serialization stream
434  * \param[in] in Value to serialize
435  *
436  * \return RTI_TRUE on success, RTI_FALSE on failure
437  */
438 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
439 CDR_Stream_serialize_long_double(struct CDR_Stream_t *cdrs,
440  const RTI_DOUBLE128 * in);
441 
442 /*ci
443  * \brief
444  * Deserialize a long double from a stream
445  *
446  * \param[in] cdrs Deserialization buffer
447  * \param[out] out Deserialized instance
448  *
449  * \return RTI_TRUE on success, RTI_FALSE on failure
450  */
451 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
452 CDR_Stream_deserialize_long_double(struct CDR_Stream_t *cdrs,
453  RTI_DOUBLE128 * out);
454 
455 /*ci
456  * \brief
457  * Serialize a string with a CDR stream
458  *
459  * \param[in] cdrs Serialization stream
460  * \param[in] in Pointer to string
461  * \param[in] max_length Maximum length of string
462  *
463  * \return RTI_TRUE on success, RTI_FALSE on failure
464  */
465 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
466 CDR_Stream_serialize_string(struct CDR_Stream_t *cdrs,
467  const char *in, RTI_UINT32 max_length);
468 
469 /*ci
470  * \brief
471  * Deserialize a string from a stream
472  *
473  * \param[in] cdrs Deserialization buffer
474  * \param[out] out Deserialized instance
475  * \param[in] max_length Maximum length of string
476  *
477  * \return RTI_TRUE on success, RTI_FALSE on failure
478  */
479 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
480 CDR_Stream_deserialize_string(struct CDR_Stream_t *cdrs,
481  char *out, RTI_UINT32 max_length);
482 
483 /*ci
484  * \brief
485  * Serialize a wstring with a CDR stream
486  *
487  * \param[in] cdrs Serialization stream
488  * \param[in] in Pointer to wstring
489  * \param[in] max_length Maximum length of wstring
490  *
491  * \return RTI_TRUE on success, RTI_FALSE on failure
492  */
493 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
494 CDR_Stream_serialize_wstring(struct CDR_Stream_t *cdrs,
495  const RTI_UINT32 *in, RTI_UINT32 max_length);
496 
497 /*ci
498  * \brief
499  * Deserialize a wstring from a stream
500  *
501  * \param[in] cdrs Deserialization buffer
502  * \param[inout] out Deserialized wstring
503  * \param[in] max_length Maximum wstring length
504  *
505  * \return RTI_TRUE on success, RTI_FALSE on failure
506  */
507 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
508 CDR_Stream_deserialize_wstring(struct CDR_Stream_t *cdrs,
509  RTI_UINT32 *out, RTI_UINT32 max_length);
510 
511 /*ci
512  * \brief
513  * Serialize unsigned short to big endian byte order with stream
514  *
515  * \param[in] cdrs Serialization stream
516  * \param[in] in Value to serialize
517  *
518  * \return RTI_TRUE on success, RTI_FALSE on failure
519  */
520 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
521 CDR_Stream_serialize_2_octets_big_endian(struct CDR_Stream_t *cdrs,
522  const RTI_UINT16 * in);
523 
524 /*ci
525  * \brief
526  * Deserialize an unsigned short with big endian byte order from a stream
527  *
528  * \param[in] cdrs Deserialization buffer
529  * \param[out] out Deserialized instance
530  *
531  * \return RTI_TRUE on success, RTI_FALSE on failure
532  */
533 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
534 CDR_Stream_deserialize_2_octets_big_endian(struct CDR_Stream_t *cdrs,
535  RTI_UINT16 * out);
536 
537 /******************************************************************************
538  * Define serialization / deserialization stream macros for primative types that
539  * are implemented by equaivalent sized base primative types
540  ******************************************************************************/
541 
542 /*ci \brief Serialize boolean in stream */
543 #define CDR_Stream_serialize_boolean(__s,__i) \
544  CDR_Stream_serialize_char(__s,((RTI_INT8*)__i))
545 
546 /*ci \brief Deserialize boolean from stream */
547 #define CDR_Stream_deserialize_boolean(__s,__i) \
548  CDR_Stream_deserialize_char(__s,((RTI_INT8*)__i))
549 
550 /*ci \brief Serialize octet into stream */
551 #define CDR_Stream_serialize_octet(__s,__i) \
552  CDR_Stream_serialize_char(__s,((RTI_INT8*)__i))
553 
554 /*ci \brief Deserialize octet from stream */
555 #define CDR_Stream_deserialize_octet(__s,__i) \
556  CDR_Stream_deserialize_char(__s,((RTI_INT8*)__i))
557 
558 /*ci \brief Serialize short into stream */
559 #define CDR_Stream_serialize_short(__s,__i) \
560  CDR_Stream_serialize_unsigned_short(__s,((RTI_UINT16*)__i))
561 
562 /*ci \brief Deserialize short from stream */
563 #define CDR_Stream_deserialize_short(__s,__i) \
564  CDR_Stream_deserialize_unsigned_short(__s,((RTI_UINT16*)__i))
565 
566 /*ci \brief Serialize wchar into stream */
567 #define CDR_Stream_serialize_wchar(__s,__i) \
568  CDR_Stream_serialize_unsigned_long(__s,(RTI_UINT32*)__i)
569 
570 /*ci \brief Deserialize wchar from stream */
571 #define CDR_Stream_deserialize_wchar(__s,__i) \
572  CDR_Stream_deserialize_unsigned_long(__s,(RTI_UINT32*)__i)
573 
574 /*ci \brief Serialize enum into stream */
575 #define CDR_Stream_serialize_enum(__s,__i) \
576  CDR_Stream_serialize_unsigned_long(__s,(RTI_UINT32*)__i)
577 
578 /*ci \brief Deserialize enum from stream */
579 #define CDR_Stream_deserialize_enum(__s,__i) \
580  CDR_Stream_deserialize_unsigned_long(__s,(RTI_UINT32*)__i)
581 
582 /*ci \brief Serialize long into stream */
583 #define CDR_Stream_serialize_long(__s,__i) \
584  CDR_Stream_serialize_unsigned_long(__s,((RTI_UINT32*)__i))
585 
586 /*ci \brief Deserialize long from stream */
587 #define CDR_Stream_deserialize_long(__s,__i) \
588  CDR_Stream_deserialize_unsigned_long(__s,((RTI_UINT32*)__i))
589 
590 /*ci \brief Serialize float into stream */
591 #define CDR_Stream_serialize_float(__s,__i) \
592  CDR_Stream_serialize_unsigned_long(__s,((RTI_UINT32*)__i))
593 
594 /*ci \brief Deserialize float from stream */
595 #define CDR_Stream_deserialize_float(__s,__i) \
596  CDR_Stream_deserialize_unsigned_long(__s,((RTI_UINT32*)__i))
597 
598 /*ci \brief Serialize long long into stream */
599 #define CDR_Stream_serialize_long_long(__s,__i) \
600  CDR_Stream_serialize_unsigned_long_long(__s,((RTI_UINT64*)__i))
601 
602 /*ci \brief Deserialize long long from stream */
603 #define CDR_Stream_deserialize_long_long(__s,__i) \
604  CDR_Stream_deserialize_unsigned_long_long(__s,((RTI_UINT64*)__i))
605 
606 /*ci \brief Serialize double into stream */
607 #define CDR_Stream_serialize_double(__s,__i) \
608  CDR_Stream_serialize_unsigned_long_long(__s,((RTI_UINT64*)__i))
609 
610 /*ci \brief Deserialize double from stream */
611 #define CDR_Stream_deserialize_double(__s,__i) \
612  CDR_Stream_deserialize_unsigned_long_long(__s,((RTI_UINT64*)__i))
613 
614 /*ci \brief Serialization function for an arbitrary type
615  *
616  * \param[inout] stream Serialization stream
617  * \param[in] sample Pointer to type to serialize
618  * \param[in] param Serialization function parameter
619  *
620  * \return RTI_TRUE on success, RTI_FALSE on failure
621  */
622 typedef RTI_BOOL
623 (*CDR_Stream_SerializeFunction) (struct CDR_Stream_t * stream,
624  const void *sample,
625  void *param);
626 
627 /*ci \brief Deserialization function for an arbitrary type
628  *
629  * \param[in] stream Deserialization stream
630  * \param[inout] sample Deserialized type from stream
631  * \param[in] param Deserialization function parameter
632  *
633  * \return RTI_TRUE on success, RTI_FALSE on failure
634  */
635 typedef RTI_BOOL
636 (*CDR_Stream_DeserializeFunction) (struct CDR_Stream_t * stream,
637  void *sample,
638  void *param);
639 
640 struct NDDS_Type_Plugin; /* forward declaration */
641 
642 /*ci \brief Get serialized size of stream buffer with a sample of a custom type
643  * with a type-plugin
644  *
645  * \param[in] plugin Custom type's type-plugin
646  * \param[in] current_alignment Stream buffer's current alignment
647  * \param[in] param Optional function parameter
648  *
649  * \return Number of bytes to serialize one sample of plugin's type
650  */
651 typedef RTI_UINT32
652 (*CDR_Stream_GetSerializedSizeFunction)(struct NDDS_Type_Plugin *plugin,
653  RTI_UINT32 current_alignment,
654  void *param);
655 
656 /******************************************************************************/
657 /*ci
658  * \brief
659  * Serialize array of bytes with stream
660  *
661  * \param[in] cdrs Serialization stream
662  * \param[in] in_array Array containing elements to serialize
663  * \param[in] length Length of array
664  *
665  * \return RTI_TRUE on success, RTI_FALSE on failure
666  */
667 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
668 CDR_Stream_serialize_byte_array(struct CDR_Stream_t *cdrs,
669  const unsigned char *in_array,
670  RTI_UINT32 length);
671 
672 /*ci
673  * \brief
674  * Deserialize an array of bytes from a stream
675  *
676  * \param[in] cdrs Deserialization stream
677  * \param[out] out Array of deserialized elements
678  * \param[in] length Length of array
679  *
680  * \return RTI_TRUE on success, RTI_FALSE on failure
681  */
682 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
683 CDR_Stream_deserialize_byte_array(struct CDR_Stream_t *cdrs,
684  unsigned char *out,
685  RTI_UINT32 length);
686 
687 /*ci \brief Get serialized size of byte array */
688 #define CDR_get_max_size_serialized_byte_array(current_alignment, length, type) \
689  (length)
690 
691 /*ci
692  * \brief
693  * Serialize array of strings with stream
694  *
695  * \param[in] cdrs Serialization stream
696  * \param[in] in Array containing elements to serialize
697  * \param[in] length Length of array
698  * \param[in] max_string_length Maximum length of string
699  * \param[in] type Type of string, char or wide char
700  *
701  * \return RTI_TRUE on success, RTI_FALSE on failure
702  */
703 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
704 CDR_Stream_serialize_string_array(struct CDR_Stream_t *cdrs,
705  const void* in,
706  RTI_UINT32 length,
707  RTI_UINT32 max_string_length,
708  CdrPrimitiveType type);
709 
710 /*ci
711  * \brief
712  * Deserialize an array of strings from a stream
713  *
714  * \param[in] cdrs Deserialization stream
715  * \param[out] out Array of deserialized strings
716  * \param[in] length Length of array
717  * \param[in] max_string_length Maximum length of string
718  * \param[in] type Type of string, char or wide char
719  *
720  * \return RTI_TRUE on success, RTI_FALSE on failure
721  */
722 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
723 CDR_Stream_deserialize_string_array(struct CDR_Stream_t *cdrs,
724  void *out,
725  RTI_UINT32 length,
726  RTI_UINT32 max_string_length,
727  CdrPrimitiveType type);
728 
729 /*ci
730  * \brief
731  * Return length in bytes of serialized string array
732  *
733  * \param[in] current_alignment Alignment of serialization buffer pointer
734  * \param[in] length Length of array
735  * \param[in] max_string_length Maximum length of string
736  * \param[in] type Type of string, char or wide char
737  *
738  * \return Number of bytes of serialized string array
739  */
740 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
741 CDR_get_max_size_serialized_string_array(RTI_UINT32 current_alignment,
742  RTI_UINT32 length,
743  RTI_UINT32 max_string_length,
744  CdrPrimitiveType type);
745 
746 /*ci
747  * \brief
748  * Serialize array of primitive type elements with stream
749  *
750  * \param[in] cdrs Serialization stream
751  * \param[in] in Array pointer
752  * \param[in] length Length of array
753  * \param[in] type Type of array element
754  *
755  * \return RTI_TRUE on success, RTI_FALSE on failure
756  */
757 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
758 CDR_Stream_serialize_primitive_array(struct CDR_Stream_t *cdrs,
759  const void* in,
760  RTI_UINT32 length,
761  CdrPrimitiveType type);
762 
763 /*ci
764  * \brief
765  * Deserialize an array of primitive type elements from a stream
766  *
767  * \param[in] cdrs Deserialization stream
768  * \param[out] out Array of deserialized elements
769  * \param[in] length Length of array
770  * \param[in] type Type of array element
771  *
772  * \return RTI_TRUE on success, RTI_FALSE on failure
773  */
774 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
775 CDR_Stream_deserialize_primitive_array(struct CDR_Stream_t *cdrs,
776  void* out,
777  RTI_UINT32 length,
778  CdrPrimitiveType type);
779 
780 /*ci \brief Get serialized size of primitive array
781  *
782  * \param[in] alignment Current alignment
783  * \param[in] length Array length
784  * \param[in] type Array element type
785  *
786  * \return Serialized size of primitive array, in bytes.
787  */
788 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
789 CDR_get_max_size_serialized_primitive_array(RTI_UINT32 alignment,
790  RTI_UINT32 length,
791  CdrPrimitiveType type);
792 
793 /*ci
794  * \brief
795  * Serialize array of non-primitive type elements with stream
796  *
797  * \param[in] stream Serialization stream
798  * \param[in] in Array pointer
799  * \param[in] length Length of array
800  * \param[in] element_size Size in bytes of an array element
801  * \param[in] serialize_function Serialization function per array element
802  * \param[in] param Parameter for element serialization function
803  *
804  * \return RTI_TRUE on success, RTI_FALSE on failure
805  */
806 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
807 CDR_Stream_serialize_non_primitive_array(struct CDR_Stream_t *stream,
808  const void* in,
809  RTI_UINT32 length,
810  RTI_UINT32 element_size,
811  CDR_Stream_SerializeFunction
812  serialize_function,
813  void * param);
814 
815 /*ci
816  * \brief
817  * Deserialize an array of non-primitive type elements from a stream
818  *
819  * \param[in] stream Deserialization stream
820  * \param[out] out Array of deserialized elements
821  * \param[in] length Length of array
822  * \param[in] element_size Size in bytes of an array element
823  * \param[in] deserialize_function Deserialization function per array element
824  * \param[in] param Parameter for element deserialization function
825  *
826  * \return RTI_TRUE on success, RTI_FALSE on failure
827  */
828 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
829 CDR_Stream_deserialize_non_primitive_array(struct CDR_Stream_t *stream,
830  void* out,
831  RTI_UINT32 length,
832  RTI_UINT32 element_size,
833  CDR_Stream_DeserializeFunction
834  deserialize_function,
835  void * param);
836 
837 /*ci
838  * \brief
839  * Return length in bytes of serialized non-primitive array
840  *
841  * \param[in] current_alignment Alignment of serialization buffer pointer
842  * \param[in] length Length of array
843  * \param[in] get_serialized_size_func Function returning serialized size of one
844  * element
845  * \param[in] param Parameter for element serialized size function
846  *
847  * \return Number of bytes to serialize array of non-primitive elements
848  */
849 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
850 CDR_get_max_size_serialized_non_primitive_array(RTI_UINT32 current_alignment,
851  RTI_UINT32 length,
852  CDR_Stream_GetSerializedSizeFunction
853  get_serialized_size_func,
854  void * param);
855 
856 /*ci
857  * \brief
858  * Serialize a sequence of char or wide char strings with a stream
859  *
860  * \param[in] cdrs Serialization stream
861  * \param[in] in Sequence of strings
862  * \param[in] max_string_length Maximum length of a string
863  * \param[in] type Type of string, either char or wide char
864  *
865  * \return RTI_TRUE on success, RTI_FALSE on failure
866  */
867 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
868 CDR_Stream_serialize_string_sequence(struct CDR_Stream_t *cdrs,
869  const struct REDA_Sequence* in,
870  RTI_UINT32 max_string_length,
871  CdrPrimitiveType type);
872 
873 /*ci
874  * \brief
875  * Deserialize a sequence of char or wide char strings from a stream
876  *
877  * \param[in] cdrs Deserialization stream
878  * \param[out] out Sequence of deserialized strings
879  * \param[in] max_string_length Maximum length of a string
880  * \param[in] type Type of string, either char or wide char
881  *
882  * \return RTI_TRUE on success, RTI_FALSE on failure
883  */
884 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
885 CDR_Stream_deserialize_string_sequence(struct CDR_Stream_t *cdrs,
886  struct REDA_Sequence* out,
887  RTI_UINT32 max_string_length,
888  CdrPrimitiveType type);
889 
890 /*ci
891  * \brief
892  * Return length in bytes of serialized string sequence
893  *
894  * \param[in] current_alignment Alignment of serialization buffer pointer
895  * \param[in] length Length of array
896  * \param[in] max_string_length Maximum length of a string
897  * \param[in] Type of string, either char or wide char
898  *
899  * \return Number of bytes to serialize sequence of strings
900  */
901 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
902 CDR_get_max_size_serialized_string_sequence(RTI_UINT32 current_alignment,
903  RTI_UINT32 length,
904  RTI_UINT32 max_string_length,
905  CdrPrimitiveType type);
906 
907 /*ci
908  * \brief
909  * Serialize a sequence of primitive type elements with a stream
910  *
911  * \param[in] stream Serialization stream
912  * \param[in] in Sequence of primitive elements
913  * \param[in] type Type of sequence element
914  *
915  * \return RTI_TRUE on success, RTI_FALSE on failure
916  */
917 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
918 CDR_Stream_serialize_primitive_sequence(struct CDR_Stream_t *stream,
919  const struct REDA_Sequence* in,
920  CdrPrimitiveType type);
921 
922 /*ci
923  * \brief
924  * Deserialize a sequence of primitive type elements with a stream
925  *
926  * \param[in] stream Deserialization stream
927  * \param[out] out Sequence of primitive elements
928  * \param[in] type Type of sequence element
929  *
930  * \return RTI_TRUE on success, RTI_FALSE on failure
931  */
932 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
933 CDR_Stream_deserialize_primitive_sequence(struct CDR_Stream_t *stream,
934  struct REDA_Sequence* out,
935  CdrPrimitiveType type);
936 
937 /*ci
938  * \brief
939  * Return length in bytes of serialized primitive sequence
940  *
941  * \param[in] current_alignment Alignment of serialization buffer pointer
942  * \param[in] length Length of sequence
943  * \param[in] type Type of sequenece element
944  *
945  * \return Number of bytes to serialize sequence of primitives
946  */
947 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
948 CDR_get_max_size_serialized_primitive_sequence(RTI_UINT32 current_alignment,
949  RTI_UINT32 length,
950  CdrPrimitiveType type);
951 
952 /*ci
953  * \brief
954  * Serialize a sequence of non-primitive type elements with a stream
955  *
956  * \param[in] stream Serialization stream
957  * \param[in] in Sequence of non-primitive elements
958  * \param[in] serialize_function Serialization function of the non-primitive type
959  * \param[in] param Parameter for serialize function of non-primitive type
960  *
961  * \return RTI_TRUE on success, RTI_FALSE on failure
962  */
963 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
964 CDR_Stream_serialize_non_primitive_sequence(struct CDR_Stream_t *stream,
965  const struct REDA_Sequence* in,
966  CDR_Stream_SerializeFunction
967  serialize_function,
968  void * param);
969 
970 /*ci
971  * \brief
972  * Deserialize a sequence of non-primitive type elements with a stream
973  *
974  * \param[in] stream Deserialization stream
975  * \param[out] out Sequence of non-primitive elements
976  * \param[in] deserialize_function Deserialization function of a non-primitive
977  * type
978  * \param[in] param Parameter for deserialize function of non-primitive type
979  *
980  * \return RTI_TRUE on success, RTI_FALSE on failure
981  */
982 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
983 CDR_Stream_deserialize_non_primitive_sequence(struct CDR_Stream_t *stream,
984  struct REDA_Sequence* out,
985  CDR_Stream_DeserializeFunction
986  deserialize_function,
987  void * param);
988 
989 /*ci
990  * \brief
991  * Return the length in bytes to serialize a sequence of non-primitive type
992  * elements
993  *
994  * \param[in] current_alignment Alignment of serialization buffer
995  * \param[in] length Length of sequence
996  * \param[in] get_serialized_size_func Function returning the length in bytes of
997  * one serialized sequence element
998  * type
999  * \param[in] param Parameter for serialized size function of non-primitive type
1000  *
1001  * \return RTI_TRUE on success, RTI_FALSE on failure
1002  */
1003 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1004 CDR_get_max_size_serialized_non_primitive_sequence(RTI_UINT32 current_alignment,
1005  RTI_UINT32 length,
1006  CDR_Stream_GetSerializedSizeFunction
1007  get_serialized_size_func,
1008  void * param);
1009 
1010 /*ci
1011  * \brief
1012  * Serialize a sequence of properties with a stream
1013  *
1014  * \param[inout] stream Serialization stream
1015  * \param[in] data Sequence of properties to serialize
1016  * \param[in] param Parameter for property serialization function
1017  *
1018  * \return RTI_TRUE on success, RTI_FALSE on failure
1019  */
1020 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
1021 CDR_Stream_serialize_property_sequence(struct CDR_Stream_t *stream,
1022  const void *data,
1023  void *param);
1024 
1025 /*ci
1026  * \brief
1027  * Return the size of additional padding in bytes to a buffer to get desired
1028  * alignment
1029  *
1030  * \param[in] current_size Current position of buffer
1031  * \param[in] align Desired alignment
1032  *
1033  * \return Number of bytes to add to current buffer to be at desired alignment
1034  */
1035 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1036 CDR_get_pad_size(RTI_UINT32 current_size, RTI_UINT8 align);
1037 
1038 
1039 /*ci \brief Align current location to specified alignment
1040  * \param[in] location Current position
1041  * \param[in] alignment Desired alignment
1042  *
1043  * \return New position, at or greater than input location, at the desired
1044  * alignment
1045  */
1046 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1047 CDR_align_upwards(RTI_UINT32 location,
1048  RTI_UINT8 alignment);
1049 
1050 /*ci \brief Serialize a byte into a stream
1051  * \param[inout] me Serialization stream
1052  * \param[in] in Byte to serialize
1053  *
1054  */
1055 CDRDllExport void
1056 CDR_Stream_serialize_1_byte(struct CDR_Stream_t *me,
1057  const RTI_INT8 *in);
1058 
1059 /*ci \brief Deserialize a byte from a stream
1060  * \param[in] me Deserialization stream
1061  * \param[inout] out Deserialized byte
1062  *
1063  */
1064 CDRDllExport void
1065 CDR_Stream_deserialize_1_byte(struct CDR_Stream_t *me,
1066  RTI_INT8 *out);
1067 
1068 
1069 /*ci \brief Get size of serialized and aligned short
1070  * \param[in] current_size Current position
1071  *
1072  * \return Size of serialized and aligned short
1073  */
1074 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1075 CDR_get_2_byte_max_size_serialized(RTI_UINT32 current_size);
1076 
1077 /*ci \brief Get size of serialized and aligned long
1078  * \param[in] current_size Current position
1079  *
1080  * \return Size of serialized and aligned long
1081  */
1082 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1083 CDR_get_4_byte_max_size_serialized(RTI_UINT32 current_size);
1084 
1085 /*ci \brief Get size of serialized and aligned long long
1086  * \param[in] current_size Current position
1087  *
1088  * \return Size of serialized and aligned long long
1089  */
1090 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1091 CDR_get_8_byte_max_size_serialized(RTI_UINT32 current_size);
1092 
1093 /*ci \brief Get size of serialized and aligned long double
1094  * \param[in] current_size Current position
1095  *
1096  * \return Size of serialized and aligned long double
1097  */
1098 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1099 CDR_get_16_byte_max_size_serialized(RTI_UINT32 current_size);
1100 
1101 /*ci \brief Get size of serialized and aligned string
1102  * \param[in] current_size Current position
1103  * \param[in] length String length
1104  *
1105  * \return Size of serialized and aligned string
1106  */
1107 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1108 CDR_get_max_size_serialized_string(RTI_UINT32 current_size,
1109  RTI_UINT32 length);
1110 
1111 /*ci \brief Get size of serialized and aligned wstring
1112  * \param[in] current_size Current position
1113  * \param[in] length Wstring length, in Wchars
1114  *
1115  * \return Size of serialized and aligned wstring
1116  */
1117 MUST_CHECK_RETURN CDRDllExport RTI_UINT32
1118 CDR_get_max_size_serialized_wstring(RTI_UINT32 current_size,
1119  RTI_UINT32 length);
1120 
1121 
1122 /*ci
1123  * \brief
1124  * Whether the stream has enough space for additional bytes
1125  *
1126  * \param[in] cdrs Stream
1127  * \param[in] needed_space Additional bytes needed
1128  *
1129  * \return RTI_TRUE if stream has enough free space to serialize or deserialize
1130  * needed_space more bytes, otherwise RTI_FALSE
1131  */
1132 MUST_CHECK_RETURN CDRDllExport RTI_BOOL
1133 CDR_Stream_has_remaining_space(struct CDR_Stream_t *cdrs,
1134  RTI_UINT32 needed_space);
1135 
1136 #ifdef __cplusplus
1137 } /* extern "C" */
1138 #endif
1139 
1140 
1141 #endif /* cdr_serialize_h */
1142 
1143 /*ci @} */

RTI Connext DDS Micro Version 2.4.11 Copyright © Mon Jul 23 2018 Real-Time Innovations, Inc