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

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