qt6-migration-pipeline/external/rti_connext_dds-7.7.0/include/ndds/cdr/cdr_stream.h

/* ( (c) Copyright, Real-Time Innovations, 2003-2024.
 * All rights reserved.
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */

#ifndef cdr_stream_h
#define cdr_stream_h


 #ifndef cdr_dll_h
    #include "cdr/cdr_dll.h"
 #endif
 #ifndef osapi_type_h
    #include "osapi/osapi_type.h"
 #endif
 #ifndef reda_buffer_h
    #include "reda/reda_buffer.h"
 #endif
 #ifndef reda_seqenceNumber_h
    #include "reda/reda_sequenceNumber.h"
 #endif
 #ifndef cdr_type_h
    #include "cdr/cdr_type.h"
 #endif 
 #ifndef cdr_encapsulation_h
    #include "cdr/cdr_encapsulation.h"
 #endif
 #ifndef reda_fastBuffer_h
    #include "reda/reda_fastBuffer.h"
 #endif
  #include "xcdr/xcdr_stream.h"

/* For VxWorks defines */
#ifdef RTI_VXWORKS
	#include <vxWorks.h>
#endif

#ifdef __cplusplus
    extern "C" {
#endif

struct REDABuffer;

struct RTICdrStreamState;

/*e @struct RTICdrStream
 *\ingroup RTICdrStreamModule
 *
 * A structure that represents a stream that can handle CDR marshalling.
 *
 * CDR is a format for transferring data between architectures. CDR assumes
 * that users are aware of the endian of their architecture. CDR plaecs the
 * burden of flipping the data on the receiving side. This has the advantage that
 * if a system contains a homogeneous set of computers, then there will be no
 * need to flip the contents of the data.
 */
struct RTICdrStream; /* forward declare to appease the compiler */



/*e \ingroup RTICdrStreamModule
 * Endian.
 */
typedef RTI_UINT8 RTICdrEndian;

/*e \ingroup RTICdrStreamModule
 * Big endian in CDR.
 */
#define RTI_CDR_ENDIAN_BIG (0)

/*e \ingroup RTICdrStreamModule
 * Little endian in CDR
 */
#define RTI_CDR_ENDIAN_LITTLE (1)

/*e \ingroup RTICdrStreamModule
 * Default endian in CDR
 */
#ifdef RTI_ENDIAN_LITTLE
  #define RTI_CDR_ENDIAN_DEFAULT RTI_CDR_ENDIAN_LITTLE
#else
  #define RTI_CDR_ENDIAN_DEFAULT RTI_CDR_ENDIAN_BIG
#endif

/*e \ingroup RTICdrStreamModule
 * Used with RTICdrStream_set()
 */
#define RTI_CDR_STREAM_ALIGNMENT (8)

/*e \ingroup RTICdrStreamModule
 *
 * Initialize a CDR stream structure previusly created (either located on the
 * stack or allocated on the heap with malloc).
 * After initializing the stream, user still need to setup the buffer for 
 * marshalling.
 *
 * @see RTICdrStream_set
 */
extern RTICdrDllExport
void RTICdrStream_init(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Create a new CDR stream. After creating the stream, user still need to setup
 * the buffer for marshalling.
 *
 * @return RTICdrStream. This method can return NULL if memory could not be
 * allocated.
 * 
 * @see RTICdrStream_set
 */
extern RTICdrDllExport
struct RTICdrStream * RTICdrStream_new(void);

/*e \ingroup RTICdrStreamModule
 *
 * Delete a CDR stream. User are responsible for deallocating the buffer used
 * in the CDR stream.
 *
 * @see RTICdrStream_new
 */
extern RTICdrDllExport
void RTICdrStream_delete(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Setup the CDR stream for marshalling.
 *
 * @param me
 * @param buffer Buffer used for marshalling. Initial position in the stream need
 * to be 8 byte (RTI_CDR_STREAM_ALIGNMENT) aligned.
 * @param bufferLength. Length of the allocated buffer used for marshalling.
 */
extern RTICdrDllExport
void RTICdrStream_set(struct RTICdrStream *me, char *buffer,
		      unsigned int bufferLength);

/*e \ingroup RTICdrStreamModule
 *
 * Save the context in the stream.
 *
 * @param me
 * @param context.
 */
extern RTICdrDllExport
void RTICdrStream_setContext(
        struct RTICdrStream *me,
        const void *context);

/*e
 * \ingroup RTICdrStreamModule
 *
 * Copy all the stream from src to dest except the _tmpRelativeBuffer.
 *
 * @param dest
 * @param src.
 */
extern RTICdrDllExport
void RTICdrStream_copy(
        struct RTICdrStream *dest,
        const struct RTICdrStream *src);

/*e \ingroup RTICdrStreamModule
 *
 * Set endianness of stream.
 */
extern RTICdrDllExport
void RTICdrStream_setEndian(struct RTICdrStream *me, RTICdrEndian endian);

/*e \ingroup RTICdrStreamModule
 *
 * Get endianness of stream.
 */
extern RTICdrDllExport
RTICdrEndian RTICdrStream_getEndian(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Reset the internal current position of the buffer to the beginning without 
 * changing the content.
 */
extern RTICdrDllExport
void RTICdrStream_resetPosition(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Clear content of the buffer in the stream and reset internal current position
 * of the buffer to the beginning.
 */
extern RTICdrDllExport
void RTICdrStream_clearAndReset(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Print the content of the stream from initial to current position in hex
 * format.
 */
extern RTICdrDllExport
void RTICdrStream_print(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Set the internal current position of the stream by specifying the offset
 * from the beginning of the buffer.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_setCurrentPositionOffset(struct RTICdrStream *me,
					      int offset);

/*e \ingroup RTICdrStreamModule
 *
 * Increment the internal current position of the stream. Can be negative.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_incrementCurrentPosition(struct RTICdrStream *me,
					      int amount);

/*e \ingroup RTICdrStreamModule
 *
 * Get the amount of space (in bytes) remaining in the stream.
 *
 * The remainer is equal to the length of the stream (set by a call to
 * RTICdrStream_set()) minus RTICdrStream_getCurrentPositionOffset().
 */
extern RTICdrDllExport
int RTICdrStream_getRemainder(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Get the length of serialized/deserialized data in the stream.
 *
 * This is calculated as the offset from the current position to the initial
 * position of the buffer in the stream.
 */
extern RTICdrDllExport
int RTICdrStream_getCurrentPositionOffset(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
*/
extern RTICdrDllExport
int RTICdrStream_getRelativeCurrentPositionOffset(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Get the buffer in the stream.
 */
extern RTICdrDllExport
char* RTICdrStream_getBuffer(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Get the buffer length in the stream.
 *
 * @return The length of the buffer or, if the stream is NULL or in an
 *         inconsistent state, a negative value indicating an error. 
 */
extern RTICdrDllExport
int RTICdrStream_getBufferLength(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Set the buffer length in the stream.
 */
extern RTICdrDllExport
int RTICdrStream_setBufferLength(struct RTICdrStream *me, int newLength);

/*e \ingroup RTICdrStreamModule
 *
 * Get the userData in the stream.
 * Currently this is only used for return/getSerializedSampleStreamForFilter().
 */
extern RTICdrDllExport
void* RTICdrStream_getUserData(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Set the userData in the stream.
 * Currently this is only used for return/getSerializedSampleStreamForFilter().
 */
extern RTICdrDllExport
void RTICdrStream_setUserData(struct RTICdrStream *me, void *newUserData);

/*e \ingroup RTICdrStreamModule
 *
 * Append bytes from another stream to this stream by specifying the number
 * of bytes to copy.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_append(
    struct RTICdrStream *me,
    const struct RTICdrStream *copyFrom,
    int bytesToCopy);

/*e \ingroup RTICdrStreamModule
 *
 * Copy the entire content of another stream to the end of this stream.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_appendFull(
    struct RTICdrStream *me,
    const struct RTICdrStream *copy);

/*e \ingroup RTICdrStreamModule
 *
 * Check if there is enough room left in the buffer to serialize/deserialize
 * data of the given size.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_checkSize(
    const struct RTICdrStream *me,
    unsigned int size);

/*e \ingroup RTICdrStreamModule
 *
 * Restore stream back to previous state.
 *
 * @param me \bin This.
 */
extern RTICdrDllExport
void RTICdrStream_popState(
    struct RTICdrStream *me,
    const struct RTICdrStreamState *state);

/*e \ingroup RTICdrStreamModule
 *
 * Restore stream back to previous state without resting the alignment
 *
 * @param me \bin This.
 */
extern RTICdrDllExport
void RTICdrStream_popStateNoAlign(
    struct RTICdrStream *me,
    const struct RTICdrStreamState *state);

/*e \ingroup RTICdrStreamModule
 *
 * Save current state of stream
 *
 * @param me \bin This.
 */
extern RTICdrDllExport
void RTICdrStream_pushState(
    struct RTICdrStream *me,
    struct RTICdrStreamState * state,
    int newLength);

/*e \ingroup RTICdrStreamModule
 *
 * Initialize a stream state structure previusly created (either located on the
 * stack or allocated on the heap with malloc).
 *
 * @param me \bin This.
 */
extern RTICdrDllExport
void RTICdrStreamState_init(struct RTICdrStreamState * state);

/*e \ingroup RTICdrStreamModule
 *
 * Get the current buffer position
 */
extern RTICdrDllExport
char* RTICdrStream_getCurrentPosition(const struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Set the current buffer position
 */
extern RTICdrDllExport
char* RTICdrStream_setCurrentPosition(
    struct RTICdrStream *me, 
    char *newPosition);

/*e \ingroup RTICdrStreamModule
 *
 * Resets the alignment to a logical 0
 */
extern RTICdrDllExport
char * RTICdrStream_resetAlignment(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Resets the alignment to a logical offset
 */
extern RTICdrDllExport
char * RTICdrStream_resetAlignmentWithOffset(
    struct RTICdrStream *me,
    int offset);

/*e \ingroup RTICdrStreamModule
 *
 * Restores the alignment
 */
extern RTICdrDllExport
void RTICdrStream_restoreAlignment(
    struct RTICdrStream *me,
    char * position);

/*e \ingroup RTICdrStreamModule
 *
 * Gets the value of the dirty bit
 */
extern RTICdrDllExport
RTIBool RTICdrStream_isDirty(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Gets the value of the dirty bit
 */
extern RTICdrDllExport
void RTICdrStream_setDirtyBit(
    struct RTICdrStream *me, RTIBool value);

/*e \ingroup RTICdrStreamModule
 *
 * Returns whether zeroOnAlign is enabled or not
 */
extern RTICdrDllExport
RTIBool RTICdrStream_isZeroOnAlign(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * If TRUE, when align is called on this stream, the bytes
 * that are skipped will be zeroed.
 *
 * By defalt this is disabled.
 */
extern RTICdrDllExport
void RTICdrStream_setZeroOnAlign(
    struct RTICdrStream *me, RTIBool value);

/*e \defgroup RTICdrStreamSafeModule basic serialize/deserialize/skip
 * \ingroup RTICdr
 *
 * Methods to align, check buffer size and serialize/deserialize/skip data.
 * 
 * According to the CDR specificaton, all primitive types have alignment
 * restriction. These methods take care of the alignment
 * and check to make sure there is enough room in the buffer
 * before serializing the actual data. For most users, they can just use these
 * methods without worying about alignment/buffer size problems.
 *
 * For advanced users, if you want to take care of alignment and buffer size
 * problem yourself, you can use the corresponding fast methods.
 */

/*e \defgroup RTICdrStreamSafeSerializeModule serialize
 * \ingroup RTICdrStreamSafeModule
 */

/*e \defgroup RTICdrStreamSafeDeserializeModule deserialize
 * \ingroup RTICdrStreamSafeModule
 */

/*e \defgroup RTICdrStreamSafeSerializeFromStreamModule serializeFromStream
 * \ingroup RTICdrStreamSafeModule
 */

/*e \defgroup RTICdrStreamSafeEqualFromStreamModule equalFromStream
 * \ingroup RTICdrStreamSafeModule
 */

/*e \defgroup RTICdrStreamSafeEqualZeroModule equalZero
 * \ingroup RTICdrStreamSafeModule
 */

/*e \defgroup RTICdrStreamSafeSkipModule skip
 * \ingroup RTICdrStreamSafeModule
 */

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR char type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeChar(
    struct RTICdrStream *me,
    const RTICdrChar *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR char type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeChar(
    struct RTICdrStream *me, 
    RTICdrChar *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR char type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeCharFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR char type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalCharFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR char type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipChar(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR wchar type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeWchar(
    struct RTICdrStream *me, 
    const RTICdrWchar *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR wchar type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeWchar(
    struct RTICdrStream *me,
    RTICdrWchar *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR wchar type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeWcharFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR wchar type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalWcharFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR wchar type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipWchar(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR CORBA WChar type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeCORBAWChar(
    struct RTICdrStream *me,
    const void *in,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR CORBA WChar type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeCORBAWChar(
    struct RTICdrStream *me,
    void *out,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR octet type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeOctet(
    struct RTICdrStream *me,
    const RTICdrOctet *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR octet type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeOctet(
    struct RTICdrStream *me,
    RTICdrOctet *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR octet type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeOctetFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR octet type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalOctetFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR octet type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipOctet(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeShort(
    struct RTICdrStream *me,
    const RTICdrShort *in );

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeShort(
    struct RTICdrStream *me,
    RTICdrShort *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR short type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeShortFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR short type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalShortFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipShort(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR unsigned short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedShort(
    struct RTICdrStream *me,
    const RTICdrUnsignedShort *in );

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR unsigned short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeUnsignedShort(
    struct RTICdrStream *me,
    RTICdrUnsignedShort *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR unsigned short type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedShortFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR unsigned short type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedShortFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR unsigned short type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipUnsignedShort(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLong(
    struct RTICdrStream *me,
    const RTICdrLong *in);

/*e \ingroup RTICdrStreamSafeDeseriaizeModule
 * Deserialize a CDR long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeLong(
    struct RTICdrStream *me, 
    RTICdrLong *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipLong(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR unsigned long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedLong(
    struct RTICdrStream *me,
    const RTICdrUnsignedLong *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR unsigned long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeUnsignedLong(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR unsigned long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedLongFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR unsigned long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedLongFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR unsigned long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipUnsignedLong(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR long long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongLong(
    struct RTICdrStream *me,
    const RTICdrLongLong *in );

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR long long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeLongLong(
    struct RTICdrStream *me,
    RTICdrLongLong *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR long long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongLongFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR long long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongLongFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR long long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipLongLong(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR unsigned long long type.
 */
extern RTICdrDllExport RTIBool
RTICdrStream_serializeUnsignedLongLong(
    struct RTICdrStream *me,
    const RTICdrUnsignedLongLong *in );

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR unsigned long long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeUnsignedLongLong(
    struct RTICdrStream *me,
    RTICdrUnsignedLongLong *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR unsigned long long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedLongLongFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR unsigned long long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedLongLongFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR unsigned long long type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipUnsignedLongLong(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR float type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeFloat(
    struct RTICdrStream *me,
    const RTICdrFloat *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR float type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeFloat(
    struct RTICdrStream *me,
    RTICdrFloat *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR float type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeFloatFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR float type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalFloatFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR float type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipFloat(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeDouble(
    struct RTICdrStream *me,
    const RTICdrDouble *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeDouble(
    struct RTICdrStream *me,
    RTICdrDouble *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR double type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeDoubleFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR double type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalDoubleFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipDouble(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerialzieModule
 * Serialize a CDR long double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongDouble(
    struct RTICdrStream *me,
    const RTICdrLongDouble *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR long double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeLongDouble(
    struct RTICdrStream *me,
    RTICdrLongDouble *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR long double type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongDoubleFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR long double type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongDoubleFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR long double type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipLongDouble(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR boolean type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeBoolean(
    struct RTICdrStream *me, 
    const RTICdrBoolean *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR boolean type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeBoolean(
    struct RTICdrStream *me, 
    RTICdrBoolean *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR boolean type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeBooleanFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR boolean type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalBooleanFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR boolean type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipBoolean(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a CDR enum type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeEnum(
    struct RTICdrStream *me,
    const RTICdrEnum *in);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a CDR enum type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeEnum(
    struct RTICdrStream *me,
    RTICdrEnum *out);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a CDR enum type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeEnumFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of a CDR enum type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalEnumFromStream(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a CDR enum type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipEnum(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSerializeModule
 *
 * Serialize a boolean of variable size
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeVariableSizedBoolean(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong size);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserialize an boolean of variable size
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeVariableSizedBoolean(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong size);

extern RTICdrDllExport
RTIBool RTICdrStream_serializeSequenceNumber(
    struct RTICdrStream *me,
    const struct REDASequenceNumber *sn);

extern RTICdrDllExport
RTIBool RTICdrStream_deserializeSequenceNumber(
    struct RTICdrStream *me,
    struct REDASequenceNumber *sn);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveArray(
    struct RTICdrStream *me,
    const void *in, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of primitive CDR type without aligning
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveArrayFast(
    struct RTICdrStream *me,
    const void *in, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitiveArray(
    struct RTICdrStream *me,
    void *out, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitiveArrayFast(
    struct RTICdrStream *me,
    void *out, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a fixed size array of CDR primitive type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveArrayFromStream(
    struct RTICdrStream *me, struct RTICdrStream *in,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of fixed size array of CDR primitive type between streams.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalPrimitiveArrayFromStream(
    struct RTICdrStream *me, struct RTICdrStream *other,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeEqualZeroModule
 * Compare equality of fixed size array of CDR primitive type with zero.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalZeroPrimitiveArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitiveArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of primitive CDR type and return number of bytes skipped.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitiveArrayAndGetLength(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type,
    RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize an array of primitive pointers CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitivePointerArray(
    struct RTICdrStream *me,
    const void **in,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize an array of primitive pointers CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitivePointerArray(
    struct RTICdrStream *me,
    void ** out, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip an array of primitive pointers CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitivePointerArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of CORBA WChar CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeCORBAWCharArray(
    struct RTICdrStream *me,
    const void *in, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of CORBA WChar CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeCORBAWCharArray(
    struct RTICdrStream *me,
    void *out, RTICdrUnsignedLong length,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Serialize a fixed size array of variable sized booleans
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeVariableSizedBooleanArray(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong size);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of variable sized booleans
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeVariableSizedBooleanArray(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong size);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveSequence(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of primitive CDR type without align (length or content)
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveSequenceFast(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitiveSequence(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitiveSequenceFast(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a variable size sequence of CDR primitive type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitiveSequenceFromStream(
    struct RTICdrStream *me, struct RTICdrStream *in,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of variable size sequence of CDR primitive type between streams.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalPrimitiveSequenceFromStream(
    struct RTICdrStream *me, struct RTICdrStream *other,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitiveSequence(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of primitive CDR type and return number of bytes skipped.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitiveSequenceAndGetLength(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrPrimitiveType type,
    RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of CORBA WChar CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeCORBAWCharSequence(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of primitive CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeCORBAWCharSequence(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of primitive pointer CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializePrimitivePointerSequence(
    struct RTICdrStream *me,
    const void **in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of primitive pointer CDR type. 
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializePrimitivePointerSequence(
    struct RTICdrStream *me,
    void **out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of primitive pointer CDR type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipPrimitivePointerSequence(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 *
 * Serialize a variable size sequence of variable size boolean
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeVariableSizedBooleanSequence(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong size);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserialize a variable size sequence of variable size boolean
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeVariableSizedBooleanSequence(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong size);

/*e \ingroup RTICdrStreamSafeSerializeModule
 *
 * Prototype for all serialize methods.
 *
 * Transforming structure into a machine-independent stream of bytes that
 * can be sent across the network.
 *
 * This method is called when a sample is written by a writer.
 *
 * @param stream \b InOut. Stream used for serialization.
 * @param in \b In. User type to be serialized.
 * @param serializeParam \b In. Optional serialize parameter.
 *
 * @return RTI_TRUE if successful. Otherwise, return RTI_FALSE.
 */
typedef RTIBool (*RTICdrStreamSerializeFunction)(
    void *endpointData, 
    const void *in,
    struct RTICdrStream *stream,
    RTIBool serializeEncapsulation,
    RTIEncapsulationId encapsulationId,
    RTIBool serializeData, 
    void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Prototype for all deserialize methods.
 *
 * Transforming structure from machine-independent stream of bytes to
 * user data structure.
 *
 * This method is called when a sample is received by a
 * reader.
 *
 * @param stream \b InOut. Stream used for deserialization.
 * @param out \b Out. User type to be deserialized to.
 * @param deserializeParam \b In. Optional deserialize parameter.
 *
 * @return RTI_TRUE if successful. Otherwise, return RTI_FALSE.
 */
typedef RTIBool (*RTICdrStreamDeserializeFunction)(
    void *endpointData,
    void *out,
    struct RTICdrStream *stream,
    RTIBool deserializeEncapsulation, 
    RTIBool deserializeSample,
    void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSkipModule
 *
 * Prototype for all skip methods.
 *
 * Skipping an element in the sample.
 *
 * @return RTI_TRUE if successful. Otherwise, return RTI_FALSE.
 */
typedef RTIBool (*RTICdrStreamSkipFunction)(
    void *endpointData,
    struct RTICdrStream *me,
    RTIBool skipEncapsulation, 
    RTIBool skipSample,
    void * endpointPluginQos);

/*e
 * \ingroup RTICdrStreamGetBufferWithSizeFunction
 *
 * Prototype for a function that gets a buffer with a given size.
 *
 * Get a buffer of a specific size.
 *
 * @param userData \b In. Object from where the buffer is obtained.
 * @param buffer \b In-Out. Buffer returned by the queue
 * @param bufferSize \b In. The size of the buffer requested
 * @param worker \b In. Thread worker
 *
 * @return RTI_TRUE if successful. Otherwise, return RTI_FALSE.
 */
typedef RTIBool (*RTICdrStreamGetBufferWithSizeFunction)(
    void *userData,
    struct REDABuffer *buffer,
    RTICdrUnsignedLong bufferSize,
    struct REDAWorker *worker);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeNonPrimitiveArray(
    struct RTICdrStream *me, const void *in, RTICdrUnsignedLong length,
    unsigned int elementSize, RTICdrStreamSerializeFunction serializeFunction,
    RTIBool serializeEncapsulation, 
    RTIEncapsulationId encapsulationId,
    RTIBool serializeSample, 
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeNonPrimitiveArray(
    struct RTICdrStream *me, void *out, RTICdrUnsignedLong length,
    unsigned int elementSize,
    RTICdrStreamDeserializeFunction deserializeFunction,
    RTIBool deserializeEncapsulation, RTIBool deserializeSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipNonPrimitiveArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrStreamSkipFunction skipFunction,
    RTIBool skipEncapsulation, RTIBool skipSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of non-primitive pointer type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeNonPrimitivePointerArray(
    struct RTICdrStream *me, const void ** in, RTICdrUnsignedLong length,
    unsigned int elementSize, RTICdrStreamSerializeFunction serializeFunction,
    RTIBool serializeEncapsulation, 
    RTIEncapsulationId encapsulationId,
    RTIBool serializeData, 
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of non-primitive type pointer type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeNonPrimitivePointerArray(
    struct RTICdrStream *me, void **out, RTICdrUnsignedLong length,
    unsigned int elementSize,
    RTICdrStreamDeserializeFunction deserializeFunction,
    RTIBool deserializeEncapsulation, RTIBool deserializeSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeNonPrimitiveSequence(
    struct RTICdrStream *me, const void *in,
    RTICdrUnsignedLong numberOfElements, RTICdrUnsignedLong maximumLength,
    unsigned int elementSize,
    RTICdrStreamSerializeFunction serializeFunction,
    RTIBool serializeEncapsulation, 
    RTIEncapsulationId encapsulationId,    
    RTIBool serializeData, 
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeNonPrimitiveSequence(
    struct RTICdrStream *me, void *out, RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength, unsigned int elementSize,
    RTICdrStreamDeserializeFunction deserializeFunction,
    RTIBool deserializeEncapsulation, RTIBool deserializeSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of non-primitive type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipNonPrimitiveSequence(
    struct RTICdrStream *me, 
    RTICdrUnsignedLong *numberOfElements,
    RTICdrStreamSkipFunction skipFunction,
    RTIBool skipEncapsulation, RTIBool skipSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of non-primitive pointer type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeNonPrimitivePointerSequence(
    struct RTICdrStream *me, const void **in,
    RTICdrUnsignedLong numberOfElements, RTICdrUnsignedLong maximumLength,
    RTICdrStreamSerializeFunction serializeFunction,
    RTIBool serializeEncapsulation, 
    RTIEncapsulationId encapsulationId,
    RTIBool serializeData,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of non-primitive pointer type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeNonPrimitivePointerSequence(
    struct RTICdrStream *me, void **out, RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrStreamDeserializeFunction deserializeFunction,
    RTIBool deserializeEncapsulation, RTIBool deserializeSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of non-primitive pointer type.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipNonPrimitivePointerSequence(
    struct RTICdrStream *me, 
    RTICdrUnsignedLong *numberOfElements,
    RTICdrStreamSkipFunction skipFunction,
    RTIBool deserializeEncapsulation, RTIBool deserializeSample,
    void *endpointData, void *endpointPluginQos);

/*e \ingroup RTICdrTypeSizeModule
 * This method is called to get the deserialized size of the input sample
 */
typedef RTIBool (*RTICdrTypeGetDeserializedSampleSizeFunction)(
    void * endpointData,
    unsigned int * size,
    RTIBool skipEncapsulation,
    RTIBool skipSample,
    unsigned int currentAlignment,
    RTIBool onlyMembers,
    struct RTICdrStream *stream,
    void *endpointPluginQos);

/*e \ingroup RTICdrTypeSizeModule
 * This method is called to get the deserialized size of the input sequence
 */
extern RTICdrDllExport RTIBool
RTICdrStream_getNonPrimitiveSequenceDeserializedSize(
    void * endpointData,
    unsigned int * size,
    RTICdrTypeGetDeserializedSampleSizeFunction
        getDeserializedSampleSizeFunction,
    unsigned int elementSize,
    unsigned int currentAlignment,
    struct RTICdrStream *stream,
    void *endpointPluginQos);

/*e \ingroup RTICdrTypeDeserializeModule
*/
typedef RTIBool (*RTICdrTypeInitializeDeserializationBufferPointersFromStream)(
    void * endpoint_data,
    void * sample,
    RTIBool skip_encapsulation,
    RTIBool skip_sample,
    struct REDABufferManager *buffer_manager,
    struct RTICdrStream *stream,
    void *endpoint_plugin_qos);

/*e \ingroup RTICdrTypeDeserializeModule
*/
extern RTICdrDllExport RTIBool
RTICdrStream_initializeDesBufferPointersFromStreamInNonPrimitiveSeq(
    void * endpointData,
    void **bufferPtr,
    RTICdrUnsignedLong * sequenceLength,
    RTICdrTypeInitializeDeserializationBufferPointersFromStream
        initDesBufferFunction,
    unsigned int elementSize,
    struct REDABufferManager *buffer_manager,
    struct RTICdrStream *stream,
    void *endpointPluginQos);

/*e \ingroup RTICdrTypeDeserializeModule
*/
typedef RTIBool (*RTICdrTypeInitializeDeserializationBufferPointersFromSample)(
        void *endpoint_data,
        void *dstSample,
        struct REDABufferManager *buffer_manager,
        const void *srcSample);

/*e \ingroup RTICdrTypeDeserializeModule
 * This method is called to get the deserialized size of the input sequence
 */
extern RTICdrDllExport RTIBool
RTICdrStream_initializeDesBufferPointersFromSampleInNonPrimitiveSeq(
    void * endpointData,
    void **dstBufferPtr,
    const void * srcBuffer,
    RTICdrUnsignedLong sequenceLength,
    RTICdrTypeInitializeDeserializationBufferPointersFromSample
        initDesBufferFunction,
    unsigned int elementSize,
    struct REDABufferManager *buffer_manager);

/*e \ingroup RTICdrStreamSafeSerializeModule
 *
 * Serialize string.
 *
 * @param me This
 * @param in String terminated with a single terminating null character.
 * @param maximumLength Maximum length of string, including terminating null character.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeString(
    struct RTICdrStream *me,
    const RTICdrChar *in,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserialize string. The memory for *out is reallocated to fit the new size.
 *
 * @param me This
 * @param out Buffer to store the string.
 * @param maximumLength Maximum length of string, including terminating null character.
 *
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeString(
    struct RTICdrStream *me,
    RTICdrChar *out,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserializes a string into *out. 
 *
 * @param me This
 * @param out Buffer to store the string (as a double pointer). String is stored in *out
 * @param maximumLength Maximum length of string, including terminating null character
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringEx(
    struct RTICdrStream *me, 
    RTICdrChar **out, 
    RTICdrUnsignedLong maximumLength,
    RTIBool realloc);


/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a string type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeStringFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of string type between streams.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalStringFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *other,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeSkipModule
 *
 * Skip string.
 *
 * @param me This
 * @param maximumLength Maximum length of string, including terminating null character.
 *
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipString(
    struct RTICdrStream *me,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeSkipModule
 *
 * Skip string and return the number of bytes skipped.
 *
 * @param me This
 * @param maximumLength Maximum length of string, including terminating null character. 
 *
*/
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringAndGetLength(struct RTICdrStream *me,
    RTICdrUnsignedLong maximumLength, RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 *
 * Serialize wstring.
 *
 * @param me this
 * @param in wstring value to be deserialized consists of wchar terminated
 * by single null wide character.
 * @param maximumLength Maximum number of two-octets in wstring, including terminating null character.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeWstring(
    struct RTICdrStream *me,
    const RTICdrWchar *in,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserialize wstring.
 *
 * @param me This
 * @param out Buffer to store the wide string.
 * @param maximumLength Maximum length of wide string, including terminating null character.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeWstring(
    struct RTICdrStream *me,
    RTICdrWchar *out,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 *
 * Deserialize wide string. The memory for *out is reallocated to fit the new size.
 *
 * @param me This
 * @param out Buffer to store the string.
 * @param maximumLength Maximum length of string, including terminating null character.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeWstringEx(
    struct RTICdrStream *me, 
    RTICdrWchar **out, 
    RTICdrUnsignedLong maximumLength,
    RTIBool realloc);

/*e \ingroup RTICdrStreamSafeSerializeFromStreamModule
 * Re-serialize a wide string type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeWstringFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *in,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeEqualFromStreamModule
 * Compare equality of wide string type between streams.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalWstringFromStream(
    struct RTICdrStream *me,
    struct RTICdrStream *other,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeEqualZeroModule
 * Compare string type from stream with default (zero) value.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalZeroWstring(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamSafeSkipModule
 *
 * Skip wstring.
 *
 * @param me This
 * @param maximumLength Maximum length of wide string, including terminating null character.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipWstring(
    struct RTICdrStream *me,
    RTICdrUnsignedLong maximumLength);

/*e \ingroup RTICdrStreamSafeSkipModule
 *
 * Skip wstring and return the number of bytes skipped.
 *
 * @param me This
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipWstringAndGetLength(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeStringArray(
    struct RTICdrStream *me,
    const void* in, 
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringArray(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringArrayEx(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTIBool reallocate);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of strings and return the number of bytes skipped.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringArrayAndGetLength(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a fixed size array of pointers to strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeStringPointerArray(
    struct RTICdrStream *me,
    const void** in, 
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of pointers to strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringPointerArray(
    struct RTICdrStream *me,
    void **out,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a fixed size array of pointers to strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringPointerArrayEx(
    struct RTICdrStream *me,
    void **out,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTIBool reallocate);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a fixed size array of pointers to strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringPointerArray(
    struct RTICdrStream *me,
    RTICdrUnsignedLong length,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeStringSequence(
    struct RTICdrStream *me,
    const void *in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringSequence(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringSequenceEx(
    struct RTICdrStream *me,
    void *out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTIBool reallocate);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of strings.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringSequence(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of strings and return the number of bytes skipped.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringSequenceAndGetLength(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTICdrUnsignedLong *result);

/*e \ingroup RTICdrStreamSafeSerializeModule
 * Serialize a variable size sequence of strings pointers.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeStringPointerSequence(
    struct RTICdrStream *me,
    const void **in,
    RTICdrUnsignedLong numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of strings pointers.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringPointerSequence(
    struct RTICdrStream *me,
    void **out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * Deserialize a variable size sequence of strings pointers.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeStringPointerSequenceEx(
    struct RTICdrStream *me,
    void **out,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumLength,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type,
    RTIBool reallocate);

/*e \ingroup RTICdrStreamSafeSkipModule
 * Skip a variable size sequence of strings pointers.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_skipStringPointerSequence(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *numberOfElements,
    RTICdrUnsignedLong maximumStringLength,
    RTICdrPrimitiveType type);

/*e \defgroup RTICdrStreamFastModule advanced serialize/deserialize
 * \ingroup RTICdr
 *
 * Methods to serialize/deserialize/skip data without doing alignment or checking
 * size.
 * 
 * This module is only meant to be used by advanced user who want to optimize
 * their code for serialization/deserialization/skipping. For most users, the safe
 * serialize/deserialize/skipping methods should be used instead, since those methods
 * take care of alignment and size issues.
 */

/*e \defgroup RTICdrStreamFastSerializeModule serialize
 * \ingroup RTICdrStreamFastModule
 */

/*e \defgroup RTICdrStreamFastDeserializeModule deserialize
 * \ingroup RTICdrStreamFastModule
 */

/*e \defgroup RTICdrStreamFastSerializeFromStreamModule serializeFromStream
 * \ingroup RTICdrStreamFastModule
 */

/*e \defgroup RTICdrStreamFastEqualFromStreamModule equalFromStream
 * \ingroup RTICdrStreamFastModule
 */

/*e \defgroup RTICdrStreamFastSkipModule skip
 * \ingroup RTICdrStreamFastModule
 */

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR char type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeCharFast(
    struct RTICdrStream *me,
    const RTICdrChar *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR char type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeCharFast(struct RTICdrStream *me, RTICdrChar *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR char type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeCharFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR char type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalCharFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR char type.
 */
extern RTICdrDllExport
void RTICdrStream_skipCharFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR wchar type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeWcharFast(struct RTICdrStream *me,
				     const RTICdrWchar *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR wchartype.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeWcharFast(struct RTICdrStream *me,
				       RTICdrWchar *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR wchar type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeWcharFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR wchar type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalWcharFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR wchartype.
 */
extern RTICdrDllExport
void RTICdrStream_skipWcharFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR octet type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeOctetFast(struct RTICdrStream *me,
				     const RTICdrOctet *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR octet type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeOctetFast(struct RTICdrStream *me,
				       RTICdrOctet *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR octet type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeOctetFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR octet type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalOctetFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR octet type.
 */
extern RTICdrDllExport
void RTICdrStream_skipOctetFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR short type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeShortFast(
    struct RTICdrStream *me,
    const RTICdrShort *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR short type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeShortFast(
    struct RTICdrStream *me,
    RTICdrShort *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR short type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeShortFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR short type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalShortFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR short type.
 */
extern RTICdrDllExport
void RTICdrStream_skipShortFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR unsigned short type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeUnsignedShortFast(
    struct RTICdrStream *me,
    const RTICdrUnsignedShort *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR unsigned short type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeUnsignedShortFast(
    struct RTICdrStream *me,
    RTICdrUnsignedShort *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR unsigned short type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedShortFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR unsigned short type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedShortFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR unsigned short type.
 */
extern RTICdrDllExport
void RTICdrStream_skipUnsignedShortFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR long type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeLongFast(
    struct RTICdrStream *me,
    const RTICdrLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR long type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeLongFast(
    struct RTICdrStream *me, 
    RTICdrLong *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR long type. 
 */
extern RTICdrDllExport
void RTICdrStream_skipLongFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR unsigned long type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeUnsignedLongFast(
    struct RTICdrStream *me,
    const RTICdrUnsignedLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR unsigned long type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeUnsignedLongFast(
    struct RTICdrStream *me,
    RTICdrUnsignedLong *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR unsigned long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedLongFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR unsigned long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedLongFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR unsigned long type.
 */
extern RTICdrDllExport
void RTICdrStream_skipUnsignedLongFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR long long type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeLongLongFast(
    struct RTICdrStream *me,
    const RTICdrLongLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR long long type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeLongLongFast(
    struct RTICdrStream *me,
    RTICdrLongLong *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR long long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongLongFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR long long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongLongFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR long long type.
 */
extern RTICdrDllExport
void RTICdrStream_skipLongLongFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR unsigned long long type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeUnsignedLongLongFast(
    struct RTICdrStream *me, const RTICdrUnsignedLongLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR unsigned long long type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeUnsignedLongLongFast(
    struct RTICdrStream *me,
    RTICdrUnsignedLongLong *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR unsigned long long type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeUnsignedLongLongFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR unsigned long long type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalUnsignedLongLongFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR unsigned long long type.
 */
extern RTICdrDllExport
void RTICdrStream_skipUnsignedLongLongFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR float type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeFloatFast(
    struct RTICdrStream *me,
    const RTICdrFloat *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR float type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeFloatFast(
    struct RTICdrStream *me,
    RTICdrFloat *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR float type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeFloatFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR float type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalFloatFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR float type.
 */
extern RTICdrDllExport
void RTICdrStream_skipFloatFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Deserialize CDR double type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeDoubleFast(
    struct RTICdrStream *me,
    const RTICdrDouble *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR double type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeDoubleFast(
    struct RTICdrStream *me,
    RTICdrDouble *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR double type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeDoubleFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR double type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalDoubleFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR double type.
 */
extern RTICdrDllExport
void RTICdrStream_skipDoubleFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Deserialize CDR long double type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeLongDoubleFast(
    struct RTICdrStream *me,
    const RTICdrLongDouble *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR long double type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeLongDoubleFast(
    struct RTICdrStream *me,
    RTICdrLongDouble *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR long double type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeLongDoubleFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR long double type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalLongDoubleFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR long double type.
 */
extern RTICdrDllExport
void RTICdrStream_skipLongDoubleFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR boolean type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeBooleanFast(
    struct RTICdrStream *me,
    const RTICdrBoolean *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR boolean type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeBooleanFast(
    struct RTICdrStream *me,
    RTICdrBoolean *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR boolean type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeBooleanFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR boolean type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalBooleanFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastModule
 * Skip CDR boolean type.
 */
extern RTICdrDllExport
void RTICdrStream_skipBooleanFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize CDR enum type.
 */
extern RTICdrDllExport
void RTICdrStream_serializeEnumFast(
    struct RTICdrStream *me,
    const RTICdrEnum *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize CDR enum type.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeEnumFast(
    struct RTICdrStream *me,
    RTICdrEnum *out);

/*e \ingroup RTICdrStreamFastSerializeFromStreamModule
 * Re-serialize a CDR enum type from one stream to another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeEnumFromStreamFast(
    struct RTICdrStream *me,
    struct RTICdrStream *in);

/*e \ingroup RTICdrStreamFastEqualFromStreamModule
 * Compare equality of a CDR enum type between one stream and another.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_equalEnumFromStreamFast(
    const struct RTICdrStream *me,
    const struct RTICdrStream *other);

/*e \ingroup RTICdrStreamFastSkipModule
 * Skip CDR enum type.
 */
extern RTICdrDllExport
void RTICdrStream_skipEnumFast(struct RTICdrStream *me);

/*e \ingroup RTICdrStreamModule
 *
 * Check if there is enough space in the buffer before doing the actual
 * alignment.
 *
 * @param me \In this
 * @param alignment \in Need to be either 1, 2, 4, or 8 according to the CDR
 * specification.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_align(struct RTICdrStream *me, int alignment);

/**
 * @brief Helper function to check if the stream is aligned to the alignment
 * we provide.
 *
 * @param me
 * @param alignment
 * @return RTIBool true if it is aligned, false otherwise.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_isAligned(
    struct RTIXCdrStream *me,
    RTIOsapiAlignment alignment);


extern RTICdrDllExport
RTIBool RTICdrStream_align_ex(
    struct RTICdrStream *me,
    int alignment,
    RTIBool zeroOnAlign);

/*e \ingroup RTICdrStreamModule
 *
 * Simply perform alignment withouth checking for buffer size.
 *
 * @param me \In this
 * @param alignment \in Need to be either 1, 2, 4, or 8 according to the CDR
 * specification.
 */
extern RTICdrDllExport
void RTICdrStream_alignFast(struct RTICdrStream *me, int alignment);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize unsigned short to big endian format.
 */
extern RTICdrDllExport
void RTICdrStream_serializeUnsignedShortToBigEndianFast(
    struct RTICdrStream *me, 
    const RTICdrUnsignedShort *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize unsigned short from big endian format.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeUnsignedShortFromBigEndianFast(
    struct RTICdrStream *me, 
    RTICdrUnsignedShort *out);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize unsigned long to big endian format.
 */
extern RTICdrDllExport
void RTICdrStream_serializeUnsignedLongToBigEndianFast(
    struct RTICdrStream *me, 
    const RTICdrUnsignedLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize unsigned long from big endian format.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeUnsignedLongFromBigEndianFast(
    struct RTICdrStream *me, 
    RTICdrUnsignedLong *out);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize big endian to unsigned long format.
 */
extern RTICdrDllExport
void RTICdrStream_serializeBigEndianToUnsignedLongFast(
    struct RTICdrStream *me, 
    const RTICdrOctet *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize big endian from unsigned long format.
 */
extern RTICdrDllExport
void RTICdrStream_deserializeBigEndianFromUnsignedLongFast(
    struct RTICdrStream *me, 
    RTICdrOctet *out);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize unsigned short to big endian format.
 */
extern RTICdrDllExport 
RTIBool RTICdrStream_serializeUnsignedShortToBigEndian(
    struct RTICdrStream *me, 
    const RTICdrUnsignedShort *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize unsigned short from big endian format.
 */
extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeUnsignedShortFromBigEndian(
    struct RTICdrStream *me, 
    RTICdrUnsignedShort *out);

/*e \ingroup RTICdrStreamFastSerializeModule
 * Serialize unsigned short to big endian format.
 */
extern RTICdrDllExport 
RTIBool RTICdrStream_serializeUnsignedLongToBigEndian(
    struct RTICdrStream *me, 
    const RTICdrUnsignedLong *in);

/*e \ingroup RTICdrStreamFastDeserializeModule
 * Deserialize unsigned short from big endian format.
 */
extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeUnsignedLongFromBigEndian(
    struct RTICdrStream *me, 
    RTICdrUnsignedLong *out);

extern RTICdrDllExport 
RTIBool RTICdrStream_setEndianFromEncapsulationDefault(
    struct RTICdrStream *me);

extern RTICdrDllExport 
RTIBool RTICdrStream_serializeCdrEncapsulationDefault(
    struct RTICdrStream *me);

extern RTICdrDllExport 
RTIBool RTICdrStream_serializeEncapsulation(
    struct RTICdrStream *me, unsigned short *kind, unsigned short *options);

extern RTICdrDllExport 
RTIBool RTICdrStream_serializeCdrEncapsulation(
    struct RTICdrStream *me, unsigned short *kind, unsigned short *options);

extern RTICdrDllExport
RTIBool RTICdrStream_serializeAndSetCdrEncapsulation(
    struct RTICdrStream *me, RTIEncapsulationId encapsulationId);

extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeCdrEncapsulationAndSetDefault(
    struct RTICdrStream *me);

extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeAndSetCdrEncapsulation(
    struct RTICdrStream *me);

extern RTICdrDllExport
RTIBool RTICdrStream_skipEncapsulation(
    struct RTICdrStream *me);

extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeEncapsulation(
    struct RTICdrStream *me, unsigned short *kind, unsigned short *options);

extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeCdrEncapsulation(
    struct RTICdrStream *me, unsigned short *kind, unsigned short *options);

extern RTICdrDllExport 
RTIBool RTICdrStream_deserializeParameterCdrEncapsulationAndSetDefault(
    struct RTICdrStream *me);

extern RTICdrDllExport
void RTICdrStream_pushEndian(
    struct RTICdrStream *me, RTICdrEndian *endian, RTIBool *needByteSwap);

extern RTICdrDllExport
void RTICdrStream_popEndian(
    struct RTICdrStream *me, RTICdrEndian *endian, RTIBool *needByteSwap);

extern RTICdrDllExport
RTIBool RTICdrStream_setCdrEncapsulationKind(
    struct RTICdrStream *me, unsigned short kind, unsigned short options);

extern RTICdrDllExport
RTIBool RTICdrStream_setEncapsulationKind(
    struct RTICdrStream *me, unsigned short kind, unsigned short options);

extern RTICdrDllExport
unsigned short RTICdrStream_getEncapsulationKind(
    struct RTICdrStream *me);

extern RTICdrDllExport
unsigned short RTICdrStream_getEncapsulationOptions(
    struct RTICdrStream *me);

extern RTICdrDllExport
void RTICdrStream_getEncapsulationSize(unsigned int size);

extern RTICdrDllExport
void RTICdrStream_computeMD5(
    struct RTICdrStream *me, RTICdrOctet * out);

/* ----------------------------------------------------------------- */
/* Extensible types definitions                                      */
/* ----------------------------------------------------------------- */

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * \brief Deserializes the next parameter header and position the stream to 
 * the beginning of the value.
 * 
 * Notice that the parameter ID and parameter length are provided as unsigned 
 * longs.
 * 
 * With extended encapsulation, the parameter ID and length
 * corresponds to the 32-bit parameter ID and length of the parameter.
 *
 * @param me \b InOut. Stream used for deserialization
 * @param state \b Out. Stream state to be restored after the parameter serialization
 * @param parameterId \b Out. Parameter ID
 * @param extended \b Out. Indicates if the paramater header was serialized
 * using extended encapsulation
 * @param mustUderstand. \b Out. Value of the must understand flag
 *
 * \return RTI_TRUE if success. Otherwise, RTI_FALSE.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_deserializeParameterHeader(
    struct RTICdrStream *me,
    struct RTICdrStreamState * state,
    RTICdrUnsignedLong * parameterId,
    RTICdrUnsignedLong * length,
    RTIBool * extended,
    RTIBool * mustUnderstand);

/*e \ingroup RTICdrStreamSafeDeserializeModule
*/
extern RTICdrDllExport
void RTICdrStream_moveToNextParameterHeader(
    struct RTICdrStream *me,
    const struct RTICdrStreamState * state,
    RTICdrUnsignedLong length);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * \brief Serializes a parameter header
 *
 * @param me \b InOut. Stream used for serialization
 * @param state \b Out. Stream state to be restored after the parameter serialization
 * @param extended \b In. Indicates whether or not the parameter must be serialized
 * with extended encapsulation
 * @param parameterId \b In. Parameter ID
 * @param mustUderstand. \b In. Value of the must understand flag
 *
 * \return Buffer position of the parameter length. NULL if failure.
 */
extern RTICdrDllExport
char * RTICdrStream_serializeParameterHeader(
    struct RTICdrStream *me,
    struct RTICdrStreamState * state,
    RTIBool extended,
    RTICdrUnsignedLong parameterId,
    RTIBool mustUnderstand);

/*e \ingroup RTICdrStreamSafeDeserializeModule
 * \brief Serializes a parameter length
 *
 * @param me \b InOut. Stream used for serialization
 * @param extended \b In. Indicates whether or not the parameter must be serialized
 * with extended encapsulation
 * @param lengthPosition \b In. Stream position where to serialize the length
 */
extern RTICdrDllExport
RTIBool RTICdrStream_serializeParameterLength(
    struct RTICdrStream *me,
    const struct RTICdrStreamState * state,
    RTIBool extended,
    char * lengthPosition);

/*e \ingroup RTICdrTypeSizeModule
 * Maximum serialized size of an extended parameter header
 */
extern RTICdrDllExport
unsigned int RTICdrStream_getExtendedParameterHeaderMaxSizeSerialized(
    unsigned int currentAlignment);

/*e \ingroup RTICdrTypeSizeModule
 * Maximum serialized size of a parameter header
 */
extern RTICdrDllExport
unsigned int RTICdrStream_getParameterHeaderMaxSizeSerialized(
    unsigned int currentAlignment);

extern RTICdrDllExport
RTIBool RTICdrStream_lookUnsignedLong(
    struct RTICdrStream *me,
    RTICdrUnsignedLong * value);

/*e
 * Return the encapsulation Id from an stream without changing the current
 * position of an stream.
 * The current possition of the stream must be at the beginning of the
 * encapsulation header.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_peekEncapsulationId(
    struct RTICdrStream *me,
    RTIXCdrEncapsulationId *id);

/*
 * This checks if a stream has compression enabled.
 */
extern RTICdrDllExport
RTIBool RTICdrStream_isCompressionEnabledOnEncapsulation(struct RTICdrStream *me);

extern RTICdrDllExport
void RTICdrStream_setEncapsulationOptionsCompressionId(
    struct RTICdrStream *me,
    RTIOsapiCompressionPluginClassId compressionId);

extern RTICdrDllExport
RTIOsapiCompressionPluginClassId
RTICdrStream_getEncapsulationOptionsCompressionId(
    const struct RTICdrStream *me);

/**
 * @brief Pack the given parameters into the options.
 *
 * See RTIXCdrEncapsulationOptions_pack for more information.
 */
extern RTICdrDllExport
void RTICdrEncapsulationOptions_pack(
    RTIEncapsulationOptions *options,
    RTICdrOctet serializedDataNumPaddingBytes,
    RTIOsapiCompressionPluginClassId compressionId,
    RTICdrOctet compressionNumPaddingBytes);

/**
 * @brief Unpack the given options into the given parameters.
 *
 * See RTIXCdrEncapsulationOptions_unpack for more information.
 */
extern RTICdrDllExport
void RTICdrEncapsulationOptions_unpack(
    RTIEncapsulationOptions options,
    RTICdrOctet *serializedDataNumPaddingBytes,
    RTIOsapiCompressionPluginClassId *compressionId,
    RTICdrOctet *compressionNumPaddingBytes);

/**
 * @brief Pack the given parameters into the stream's options.
 *
 * See RTIXCdrEncapsulationOptions_pack for more information.
 */
extern RTICdrDllExport
void RTICdrStream_packEncapsulationOptions(
    struct RTICdrStream *me,
    RTICdrOctet serializedDataNumPaddingBytes,
    RTIOsapiCompressionPluginClassId compressionId,
    RTICdrOctet compressionNumPaddingBytes);

/**
 * @brief Unpack the given stream's options into the given parameters.
 * 
 * See RTIXCdrEncapsulationOptions_unpack for more information.
 */
extern RTICdrDllExport
void RTICdrStream_unpackEncapsulationOptions(
    const struct RTICdrStream *me,
    RTICdrOctet *serializedDataNumPaddingBytes,
    RTIOsapiCompressionPluginClassId *compressionId,
    RTICdrOctet *compressionNumPaddingBytes);

/*i
 * @brief Uncompress a given compressed stream.
 * @param bufferPool. \n In. Buffer pool from where to get the buffer that is
 * going to hold the uncompressed data.
 * @param uncompressBuffer. \n In. Pointer to the buffer returned by the
 * bufferPool. The caller must return this buffer after it's done with the
 * current stream.
 * @param maxUncompressedSize. \n In. Maximum size possible for the uncompressed
 * data. This is useful to avoid large memory allocations due to tampered
 * compressed data.
 * @param worker. \n In. Thread worker
 */
extern RTICdrDllExport RTIBool RTICdrStream_uncompress(
    struct RTICdrStream *me,
    RTICdrStreamGetBufferWithSizeFunction getBufferWithSize,
    void *userData,
    struct REDABuffer *uncompressBuffer,
    RTI_UINT32 maxUncompressedSize,
    struct REDAWorker *worker);

/*
 * @brief Find the given PID in the stream.
 * If the search is successful, and moveToBody == true, the stream is positioned
 * at PID's body, otherwise, it is positioned at its length field.
 * Returns true if the given PID is found; false otherwise.
 * Function assumes that the stream is prepositioned on a PID and following
 * PIDs are organized in a continuous list that finishes with pidSentinel or with
 * the end of the buffer.
 * @param stream \n a stream to search in.
 * @param pidToFind \n a PID to Find
 * @param pidSentinel \n a PID that concludes the PIDs list
 * @param moveToBody \n should the stream move to PID's body?
 */
extern RTICdrDllExport RTIBool RTICdrStream_goToPid(
    struct RTICdrStream *me,
    RTICdrUnsignedShort pidToFind,
    RTICdrUnsignedShort pidSentinel,
    RTIBool moveToBody);


#ifdef __cplusplus
    }	/* extern "C" */
#endif

#include "cdr/cdr_stream_impl.h"

#endif /* cdr_stream_h */