/* ( (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 #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 */