RTI Connext Traditional C++ API  Version 6.1.2
HelloWorldPlugin.cxx

RTI Connext Implementation Support

Files generated by rtiddsgen that provided methods for type specific serialization and deserialization, to support the RTI Connext implementation.

HelloWorldPlugin.h

/*
WARNING: THIS FILE IS AUTO-GENERATED. DO NOT MODIFY.
This file was generated from HelloWorld.idl
using RTI Code Generator (rtiddsgen) version 3.1.2.
The rtiddsgen tool is part of the RTI Connext DDS distribution.
For more information, type 'rtiddsgen -help' at a command shell
or consult the Code Generator User's Manual.
*/
#ifndef HelloWorldPlugin_1436885487_h
#define HelloWorldPlugin_1436885487_h
#include "HelloWorld.h"
struct RTICdrStream;
#ifndef pres_typePlugin_h
#include "pres/pres_typePlugin.h"
#endif
#if (defined(RTI_WIN32) || defined (RTI_WINCE) || defined(RTI_INTIME)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, start exporting symbols.
*/
#undef NDDSUSERDllExport
#define NDDSUSERDllExport __declspec(dllexport)
#endif
extern "C"{
#define HelloWorldPlugin_get_sample PRESTypePluginDefaultEndpointData_getSample
#define HelloWorldPlugin_get_buffer PRESTypePluginDefaultEndpointData_getBuffer
#define HelloWorldPlugin_return_buffer PRESTypePluginDefaultEndpointData_returnBuffer
#define HelloWorldPlugin_create_sample PRESTypePluginDefaultEndpointData_createSample
#define HelloWorldPlugin_destroy_sample PRESTypePluginDefaultEndpointData_deleteSample
/* --------------------------------------------------------------------------------------
Support functions:
* -------------------------------------------------------------------------------------- */
NDDSUSERDllExport extern HelloWorld*
HelloWorldPluginSupport_create_data_w_params(
const struct DDS_TypeAllocationParams_t * alloc_params);
NDDSUSERDllExport extern HelloWorld*
HelloWorldPluginSupport_create_data_ex(RTIBool allocate_pointers);
NDDSUSERDllExport extern HelloWorld*
HelloWorldPluginSupport_create_data(void);
NDDSUSERDllExport extern RTIBool
HelloWorldPluginSupport_copy_data(
HelloWorld *out,
const HelloWorld *in);
NDDSUSERDllExport extern void
HelloWorldPluginSupport_destroy_data_w_params(
HelloWorld *sample,
const struct DDS_TypeDeallocationParams_t * dealloc_params);
NDDSUSERDllExport extern void
HelloWorldPluginSupport_destroy_data_ex(
HelloWorld *sample,RTIBool deallocate_pointers);
NDDSUSERDllExport extern void
HelloWorldPluginSupport_destroy_data(
HelloWorld *sample);
NDDSUSERDllExport extern void
HelloWorldPluginSupport_print_data(
const HelloWorld *sample,
const char *desc,
unsigned int indent);
/* ----------------------------------------------------------------------------
Callback functions:
* ---------------------------------------------------------------------------- */
NDDSUSERDllExport extern PRESTypePluginParticipantData
HelloWorldPlugin_on_participant_attached(
void *registration_data,
const struct PRESTypePluginParticipantInfo *participant_info,
RTIBool top_level_registration,
void *container_plugin_context,
RTICdrTypeCode *typeCode);
NDDSUSERDllExport extern void
HelloWorldPlugin_on_participant_detached(
PRESTypePluginParticipantData participant_data);
NDDSUSERDllExport extern PRESTypePluginEndpointData
HelloWorldPlugin_on_endpoint_attached(
PRESTypePluginParticipantData participant_data,
const struct PRESTypePluginEndpointInfo *endpoint_info,
RTIBool top_level_registration,
void *container_plugin_context);
NDDSUSERDllExport extern void
HelloWorldPlugin_on_endpoint_detached(
PRESTypePluginEndpointData endpoint_data);
NDDSUSERDllExport extern void
HelloWorldPlugin_return_sample(
PRESTypePluginEndpointData endpoint_data,
HelloWorld *sample,
void *handle);
NDDSUSERDllExport extern RTIBool
HelloWorldPlugin_copy_sample(
PRESTypePluginEndpointData endpoint_data,
HelloWorld *out,
const HelloWorld *in);
/* ----------------------------------------------------------------------------
(De)Serialize functions:
* ------------------------------------------------------------------------- */
NDDSUSERDllExport extern RTIBool
HelloWorldPlugin_serialize_to_cdr_buffer(
char * buffer,
unsigned int * length,
const HelloWorld *sample);
NDDSUSERDllExport extern RTIBool
HelloWorldPlugin_serialize_to_cdr_buffer_ex(
char *buffer,
unsigned int *length,
const HelloWorld *sample,
DDS_DataRepresentationId_t representation);
NDDSUSERDllExport extern RTIBool
HelloWorldPlugin_deserialize_from_cdr_buffer(
HelloWorld *sample,
const char * buffer,
unsigned int length);
#ifndef NDDS_STANDALONE_TYPE
NDDSUSERDllExport extern DDS_ReturnCode_t
HelloWorldPlugin_data_to_string(
const HelloWorld *sample,
char *str,
DDS_UnsignedLong *str_size,
const struct DDS_PrintFormatProperty *property);
#endif
NDDSUSERDllExport extern unsigned int
HelloWorldPlugin_get_serialized_sample_max_size(
PRESTypePluginEndpointData endpoint_data,
RTIBool include_encapsulation,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment);
/* --------------------------------------------------------------------------------------
Key Management functions:
* -------------------------------------------------------------------------------------- */
NDDSUSERDllExport extern PRESTypePluginKeyKind
HelloWorldPlugin_get_key_kind(void);
NDDSUSERDllExport extern unsigned int
HelloWorldPlugin_get_serialized_key_max_size(
PRESTypePluginEndpointData endpoint_data,
RTIBool include_encapsulation,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment);
NDDSUSERDllExport extern unsigned int
HelloWorldPlugin_get_serialized_key_max_size_for_keyhash(
PRESTypePluginEndpointData endpoint_data,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment);
NDDSUSERDllExport extern RTIBool
HelloWorldPlugin_deserialize_key(
PRESTypePluginEndpointData endpoint_data,
HelloWorld ** sample,
RTIBool * drop_sample,
struct RTICdrStream *stream,
RTIBool deserialize_encapsulation,
RTIBool deserialize_key,
void *endpoint_plugin_qos);
NDDSUSERDllExport extern
struct RTIXCdrInterpreterPrograms * HelloWorldPlugin_get_programs(void);
/* Plugin Functions */
NDDSUSERDllExport extern struct PRESTypePlugin*
HelloWorldPlugin_new(void);
NDDSUSERDllExport extern void
HelloWorldPlugin_delete(struct PRESTypePlugin *);
}
#if (defined(RTI_WIN32) || defined (RTI_WINCE) || defined(RTI_INTIME)) && defined(NDDS_USER_DLL_EXPORT)
/* If the code is building on Windows, stop exporting symbols.
*/
#undef NDDSUSERDllExport
#define NDDSUSERDllExport
#endif
#endif /* HelloWorldPlugin_1436885487_h */

HelloWorldPlugin.cxx

/*
WARNING: THIS FILE IS AUTO-GENERATED. DO NOT MODIFY.
This file was generated from HelloWorld.idl
using RTI Code Generator (rtiddsgen) version 3.1.2.
The rtiddsgen tool is part of the RTI Connext DDS distribution.
For more information, type 'rtiddsgen -help' at a command shell
or consult the Code Generator User's Manual.
*/
#include <string.h>
#ifndef ndds_cpp_h
#include "ndds/ndds_cpp.h"
#endif
#ifndef osapi_type_h
#include "osapi/osapi_type.h"
#endif
#ifndef osapi_heap_h
#include "osapi/osapi_heap.h"
#endif
#ifndef osapi_utility_h
#include "osapi/osapi_utility.h"
#endif
#ifndef cdr_type_h
#include "cdr/cdr_type.h"
#endif
#ifndef cdr_type_object_h
#include "cdr/cdr_typeObject.h"
#endif
#ifndef cdr_encapsulation_h
#include "cdr/cdr_encapsulation.h"
#endif
#ifndef cdr_stream_h
#include "cdr/cdr_stream.h"
#endif
#include "xcdr/xcdr_interpreter.h"
#include "xcdr/xcdr_stream.h"
#ifndef cdr_log_h
#include "cdr/cdr_log.h"
#endif
#ifndef pres_typePlugin_h
#include "pres/pres_typePlugin.h"
#endif
#include "dds_c/dds_c_typecode_impl.h"
#define RTI_CDR_CURRENT_SUBMODULE RTI_CDR_SUBMODULE_MASK_STREAM
#include <new>
#include "HelloWorldPlugin.h"
/* ----------------------------------------------------------------------------
* Type HelloWorld
* -------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Support functions:
* -------------------------------------------------------------------------- */
HelloWorld*
HelloWorldPluginSupport_create_data_w_params(
const struct DDS_TypeAllocationParams_t * alloc_params)
{
HelloWorld *sample = NULL;
if (alloc_params == NULL) {
return NULL;
}
sample = new (std::nothrow) HelloWorld();
if (sample == NULL) {
return NULL;
}
if (!HelloWorld_initialize_w_params(sample,alloc_params)) {
struct DDS_TypeDeallocationParams_t deallocParams =
DDS_TYPE_DEALLOCATION_PARAMS_DEFAULT;
deallocParams.delete_pointers = alloc_params->allocate_pointers;
deallocParams.delete_optional_members = alloc_params->allocate_pointers;
/* Coverity reports a possible uninit_use_in_call that will happen if the
allocation fails. But if the allocation fails then sample == null and
the method will return before reach this point.*/
/* coverity[uninit_use_in_call : FALSE] */
HelloWorld_finalize_w_params(sample, &deallocParams);
delete sample;
sample=NULL;
}
return sample;
}
HelloWorld *
HelloWorldPluginSupport_create_data_ex(RTIBool allocate_pointers)
{
HelloWorld *sample = NULL;
sample = new (std::nothrow) HelloWorld();
if(sample == NULL) {
return NULL;
}
if (!HelloWorld_initialize_ex(sample,allocate_pointers, RTI_TRUE)) {
/* Coverity reports a possible uninit_use_in_call that will happen if the
new fails. But if new fails then sample == null and the method will
return before reach this point. */
/* coverity[uninit_use_in_call : FALSE] */
HelloWorld_finalize_ex(sample, RTI_TRUE);
delete sample;
sample=NULL;
}
return sample;
}
HelloWorld *
HelloWorldPluginSupport_create_data(void)
{
return HelloWorldPluginSupport_create_data_ex(RTI_TRUE);
}
void
HelloWorldPluginSupport_destroy_data_w_params(
HelloWorld *sample,
const struct DDS_TypeDeallocationParams_t * dealloc_params) {
HelloWorld_finalize_w_params(sample,dealloc_params);
delete sample;
}
void
HelloWorldPluginSupport_destroy_data_ex(
HelloWorld *sample,RTIBool deallocate_pointers) {
HelloWorld_finalize_ex(sample,deallocate_pointers);
delete sample;
}
void
HelloWorldPluginSupport_destroy_data(
HelloWorld *sample) {
HelloWorldPluginSupport_destroy_data_ex(sample,RTI_TRUE);
}
RTIBool
HelloWorldPluginSupport_copy_data(
HelloWorld *dst,
const HelloWorld *src)
{
return HelloWorld_copy(dst,(const HelloWorld*) src);
}
void
HelloWorldPluginSupport_print_data(
const HelloWorld *sample,
const char *desc,
unsigned int indent_level)
{
RTICdrType_printIndent(indent_level);
if (desc != NULL) {
RTILogParamString_printPlain("%s:\n", desc);
} else {
RTILogParamString_printPlain("\n");
}
if (sample == NULL) {
RTILogParamString_printPlain("NULL\n");
return;
}
if (sample->msg==NULL) {
RTICdrType_printString(
NULL,"msg", indent_level + 1);
} else {
RTICdrType_printString(
sample->msg,"msg", indent_level + 1);
}
}
/* ----------------------------------------------------------------------------
Callback functions:
* ---------------------------------------------------------------------------- */
PRESTypePluginParticipantData
HelloWorldPlugin_on_participant_attached(
void *registration_data,
const struct PRESTypePluginParticipantInfo *participant_info,
RTIBool top_level_registration,
void *container_plugin_context,
RTICdrTypeCode *type_code)
{
struct RTIXCdrInterpreterPrograms *programs = NULL;
struct PRESTypePluginDefaultParticipantData *pd = NULL;
struct RTIXCdrInterpreterProgramsGenProperty programProperty =
RTIXCdrInterpreterProgramsGenProperty_INITIALIZER;
if (registration_data) {} /* To avoid warnings */
if (participant_info) {} /* To avoid warnings */
if (top_level_registration) {} /* To avoid warnings */
if (container_plugin_context) {} /* To avoid warnings */
if (type_code) {} /* To avoid warnings */
pd = (struct PRESTypePluginDefaultParticipantData *)
PRESTypePluginDefaultParticipantData_new(participant_info);
programProperty.generateV1Encapsulation = RTI_XCDR_TRUE;
programProperty.generateV2Encapsulation = RTI_XCDR_TRUE;
programProperty.resolveAlias = RTI_XCDR_TRUE;
programProperty.inlineStruct = RTI_XCDR_TRUE;
programProperty.optimizeEnum = RTI_XCDR_TRUE;
programProperty.unboundedSize = RTIXCdrLong_MAX;
programs = DDS_TypeCodeFactory_assert_programs_in_global_list(
DDS_TypeCodeFactory_get_instance(),
HelloWorld_get_typecode(),
&programProperty,
RTI_XCDR_PROGRAM_MASK_TYPEPLUGIN);
if (programs == NULL) {
PRESTypePluginDefaultParticipantData_delete(
(PRESTypePluginParticipantData) pd);
return NULL;
}
pd->programs = programs;
return (PRESTypePluginParticipantData)pd;
}
void
HelloWorldPlugin_on_participant_detached(
PRESTypePluginParticipantData participant_data)
{
if (participant_data != NULL) {
struct PRESTypePluginDefaultParticipantData *pd =
(struct PRESTypePluginDefaultParticipantData *)participant_data;
if (pd->programs != NULL) {
DDS_TypeCodeFactory_remove_programs_from_global_list(
DDS_TypeCodeFactory_get_instance(),
pd->programs);
pd->programs = NULL;
}
PRESTypePluginDefaultParticipantData_delete(participant_data);
}
}
PRESTypePluginEndpointData
HelloWorldPlugin_on_endpoint_attached(
PRESTypePluginParticipantData participant_data,
const struct PRESTypePluginEndpointInfo *endpoint_info,
RTIBool top_level_registration,
void *containerPluginContext)
{
PRESTypePluginEndpointData epd = NULL;
unsigned int serializedSampleMaxSize = 0;
if (top_level_registration) {} /* To avoid warnings */
if (containerPluginContext) {} /* To avoid warnings */
if (participant_data == NULL) {
return NULL;
}
epd = PRESTypePluginDefaultEndpointData_new(
participant_data,
endpoint_info,
(PRESTypePluginDefaultEndpointDataCreateSampleFunction)
HelloWorldPluginSupport_create_data,
(PRESTypePluginDefaultEndpointDataDestroySampleFunction)
HelloWorldPluginSupport_destroy_data,
NULL , NULL );
if (epd == NULL) {
return NULL;
}
if (endpoint_info->endpointKind == PRES_TYPEPLUGIN_ENDPOINT_WRITER) {
serializedSampleMaxSize = HelloWorldPlugin_get_serialized_sample_max_size(
epd,RTI_FALSE,RTI_CDR_ENCAPSULATION_ID_CDR_BE,0);
PRESTypePluginDefaultEndpointData_setMaxSizeSerializedSample(epd, serializedSampleMaxSize);
if (PRESTypePluginDefaultEndpointData_createWriterPool(
epd,
endpoint_info,
(PRESTypePluginGetSerializedSampleMaxSizeFunction)
HelloWorldPlugin_get_serialized_sample_max_size, epd,
(PRESTypePluginGetSerializedSampleSizeFunction)
PRESTypePlugin_interpretedGetSerializedSampleSize,
epd) == RTI_FALSE) {
PRESTypePluginDefaultEndpointData_delete(epd);
return NULL;
}
}
return epd;
}
void
HelloWorldPlugin_on_endpoint_detached(
PRESTypePluginEndpointData endpoint_data)
{
PRESTypePluginDefaultEndpointData_delete(endpoint_data);
}
void
HelloWorldPlugin_return_sample(
PRESTypePluginEndpointData endpoint_data,
HelloWorld *sample,
void *handle)
{
HelloWorld_finalize_optional_members(sample, RTI_TRUE);
PRESTypePluginDefaultEndpointData_returnSample(
endpoint_data, sample, handle);
}
RTIBool
HelloWorldPlugin_copy_sample(
PRESTypePluginEndpointData endpoint_data,
HelloWorld *dst,
const HelloWorld *src)
{
if (endpoint_data) {} /* To avoid warnings */
return HelloWorldPluginSupport_copy_data(dst,src);
}
/* ----------------------------------------------------------------------------
(De)Serialize functions:
* ------------------------------------------------------------------------- */
unsigned int
HelloWorldPlugin_get_serialized_sample_max_size(
PRESTypePluginEndpointData endpoint_data,
RTIBool include_encapsulation,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment);
RTIBool
HelloWorldPlugin_serialize_to_cdr_buffer_ex(
char *buffer,
unsigned int *length,
const HelloWorld *sample,
{
RTIEncapsulationId encapsulationId = RTI_CDR_ENCAPSULATION_ID_INVALID;
struct RTICdrStream stream;
struct PRESTypePluginDefaultEndpointData epd;
RTIBool result;
struct PRESTypePluginDefaultParticipantData pd;
struct RTIXCdrTypePluginProgramContext defaultProgramContext =
RTIXCdrTypePluginProgramContext_INTIALIZER;
struct PRESTypePlugin plugin;
if (length == NULL) {
return RTI_FALSE;
}
RTIOsapiMemory_zero(&epd, sizeof(struct PRESTypePluginDefaultEndpointData));
epd.programContext = defaultProgramContext;
epd._participantData = &pd;
epd.typePlugin = &plugin;
epd.programContext.endpointPluginData = &epd;
plugin.typeCode = (struct RTICdrTypeCode *)
HelloWorld_get_typecode();
pd.programs = HelloWorldPlugin_get_programs();
if (pd.programs == NULL) {
return RTI_FALSE;
}
encapsulationId = DDS_TypeCode_get_native_encapsulation(
(DDS_TypeCode *) plugin.typeCode,
representation);
if (encapsulationId == RTI_CDR_ENCAPSULATION_ID_INVALID) {
return RTI_FALSE;
}
epd._maxSizeSerializedSample =
HelloWorldPlugin_get_serialized_sample_max_size(
(PRESTypePluginEndpointData)&epd,
RTI_TRUE,
encapsulationId,
0);
if (buffer == NULL) {
*length =
PRESTypePlugin_interpretedGetSerializedSampleSize(
(PRESTypePluginEndpointData)&epd,
RTI_TRUE,
encapsulationId,
0,
sample);
if (*length == 0) {
return RTI_FALSE;
}
return RTI_TRUE;
}
RTICdrStream_init(&stream);
RTICdrStream_set(&stream, (char *)buffer, *length);
result = PRESTypePlugin_interpretedSerialize(
(PRESTypePluginEndpointData)&epd,
sample,
&stream,
RTI_TRUE,
encapsulationId,
RTI_TRUE,
NULL);
*length = RTICdrStream_getCurrentPositionOffset(&stream);
return result;
}
RTIBool
HelloWorldPlugin_serialize_to_cdr_buffer(
char *buffer,
unsigned int *length,
const HelloWorld *sample)
{
return HelloWorldPlugin_serialize_to_cdr_buffer_ex(
buffer,
length,
sample,
}
RTIBool
HelloWorldPlugin_deserialize_from_cdr_buffer(
HelloWorld *sample,
const char * buffer,
unsigned int length)
{
struct RTICdrStream stream;
struct PRESTypePluginDefaultEndpointData epd;
struct RTIXCdrTypePluginProgramContext defaultProgramContext =
RTIXCdrTypePluginProgramContext_INTIALIZER;
struct PRESTypePluginDefaultParticipantData pd;
struct PRESTypePlugin plugin;
epd.programContext = defaultProgramContext;
epd._participantData = &pd;
epd.typePlugin = &plugin;
epd.programContext.endpointPluginData = &epd;
plugin.typeCode = (struct RTICdrTypeCode *)
HelloWorld_get_typecode();
pd.programs = HelloWorldPlugin_get_programs();
if (pd.programs == NULL) {
return RTI_FALSE;
}
epd._assignabilityProperty.acceptUnknownEnumValue = RTI_XCDR_TRUE;
epd._assignabilityProperty.acceptUnknownUnionDiscriminator = RTI_XCDR_TRUE;
RTICdrStream_init(&stream);
RTICdrStream_set(&stream, (char *)buffer, length);
HelloWorld_finalize_optional_members(sample, RTI_TRUE);
return PRESTypePlugin_interpretedDeserialize(
(PRESTypePluginEndpointData)&epd, sample,
&stream, RTI_TRUE, RTI_TRUE,
NULL);
}
#ifndef NDDS_STANDALONE_TYPE
HelloWorldPlugin_data_to_string(
const HelloWorld *sample,
char *_str,
DDS_UnsignedLong *str_size,
const struct DDS_PrintFormatProperty *property)
{
DDS_DynamicData *data = NULL;
char *buffer = NULL;
unsigned int length = 0;
struct DDS_PrintFormat printFormat;
if (sample == NULL) {
}
if (str_size == NULL) {
}
if (property == NULL) {
}
if (!HelloWorldPlugin_serialize_to_cdr_buffer(
NULL,
&length,
sample)) {
}
RTIOsapiHeap_allocateBuffer(&buffer, length, RTI_OSAPI_ALIGNMENT_DEFAULT);
if (buffer == NULL) {
}
if (!HelloWorldPlugin_serialize_to_cdr_buffer(
buffer,
&length,
sample)) {
RTIOsapiHeap_freeBuffer(buffer);
}
data = DDS_DynamicData_new(
HelloWorld_get_typecode(),
if (data == NULL) {
RTIOsapiHeap_freeBuffer(buffer);
}
retCode = DDS_DynamicData_from_cdr_buffer(data, buffer, length);
if (retCode != DDS_RETCODE_OK) {
RTIOsapiHeap_freeBuffer(buffer);
DDS_DynamicData_delete(data);
return retCode;
}
retCode = DDS_PrintFormatProperty_to_print_format(
property,
&printFormat);
if (retCode != DDS_RETCODE_OK) {
RTIOsapiHeap_freeBuffer(buffer);
DDS_DynamicData_delete(data);
return retCode;
}
retCode = DDS_DynamicDataFormatter_to_string_w_format(
data,
_str,
str_size,
&printFormat);
if (retCode != DDS_RETCODE_OK) {
RTIOsapiHeap_freeBuffer(buffer);
DDS_DynamicData_delete(data);
return retCode;
}
RTIOsapiHeap_freeBuffer(buffer);
DDS_DynamicData_delete(data);
}
#endif
unsigned int
HelloWorldPlugin_get_serialized_sample_max_size(
PRESTypePluginEndpointData endpoint_data,
RTIBool include_encapsulation,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment)
{
unsigned int size;
RTIBool overflow = RTI_FALSE;
size = PRESTypePlugin_interpretedGetSerializedSampleMaxSize(
endpoint_data,&overflow,include_encapsulation,encapsulation_id,current_alignment);
if (overflow) {
size = RTI_CDR_MAX_SERIALIZED_SIZE;
}
return size;
}
/* --------------------------------------------------------------------------------------
Key Management functions:
* -------------------------------------------------------------------------------------- */
PRESTypePluginKeyKind
HelloWorldPlugin_get_key_kind(void)
{
return PRES_TYPEPLUGIN_NO_KEY;
}
RTIBool HelloWorldPlugin_deserialize_key(
PRESTypePluginEndpointData endpoint_data,
HelloWorld **sample,
RTIBool * drop_sample,
struct RTICdrStream *stream,
RTIBool deserialize_encapsulation,
RTIBool deserialize_key,
void *endpoint_plugin_qos)
{
RTIBool result;
if (drop_sample) {} /* To avoid warnings */
stream->_xTypesState.unassignable = RTI_FALSE;
result= PRESTypePlugin_interpretedDeserializeKey(
endpoint_data, (sample != NULL)?*sample:NULL, stream,
deserialize_encapsulation, deserialize_key, endpoint_plugin_qos);
if (result) {
if (stream->_xTypesState.unassignable) {
result = RTI_FALSE;
}
}
return result;
}
unsigned int
HelloWorldPlugin_get_serialized_key_max_size(
PRESTypePluginEndpointData endpoint_data,
RTIBool include_encapsulation,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment)
{
unsigned int size;
RTIBool overflow = RTI_FALSE;
size = PRESTypePlugin_interpretedGetSerializedKeyMaxSize(
endpoint_data,&overflow,include_encapsulation,encapsulation_id,current_alignment);
if (overflow) {
size = RTI_CDR_MAX_SERIALIZED_SIZE;
}
return size;
}
unsigned int
HelloWorldPlugin_get_serialized_key_max_size_for_keyhash(
PRESTypePluginEndpointData endpoint_data,
RTIEncapsulationId encapsulation_id,
unsigned int current_alignment)
{
unsigned int size;
RTIBool overflow = RTI_FALSE;
size = PRESTypePlugin_interpretedGetSerializedKeyMaxSizeForKeyhash(
endpoint_data,
&overflow,
encapsulation_id,
current_alignment);
if (overflow) {
size = RTI_CDR_MAX_SERIALIZED_SIZE;
}
return size;
}
struct RTIXCdrInterpreterPrograms * HelloWorldPlugin_get_programs(void)
{
return ::rti::xcdr::get_cdr_serialization_programs<
HelloWorld,
true, true, true>();
}
/* ------------------------------------------------------------------------
* Plug-in Installation Methods
* ------------------------------------------------------------------------ */
struct PRESTypePlugin *HelloWorldPlugin_new(void)
{
struct PRESTypePlugin *plugin = NULL;
const struct PRESTypePluginVersion PLUGIN_VERSION =
PRES_TYPE_PLUGIN_VERSION_2_0;
RTIOsapiHeap_allocateStructure(
&plugin, struct PRESTypePlugin);
if (plugin == NULL) {
return NULL;
}
plugin->version = PLUGIN_VERSION;
/* set up parent's function pointers */
plugin->onParticipantAttached =
(PRESTypePluginOnParticipantAttachedCallback)
HelloWorldPlugin_on_participant_attached;
plugin->onParticipantDetached =
(PRESTypePluginOnParticipantDetachedCallback)
HelloWorldPlugin_on_participant_detached;
plugin->onEndpointAttached =
(PRESTypePluginOnEndpointAttachedCallback)
HelloWorldPlugin_on_endpoint_attached;
plugin->onEndpointDetached =
(PRESTypePluginOnEndpointDetachedCallback)
HelloWorldPlugin_on_endpoint_detached;
plugin->copySampleFnc =
(PRESTypePluginCopySampleFunction)
HelloWorldPlugin_copy_sample;
plugin->createSampleFnc =
(PRESTypePluginCreateSampleFunction)
HelloWorldPlugin_create_sample;
plugin->destroySampleFnc =
(PRESTypePluginDestroySampleFunction)
HelloWorldPlugin_destroy_sample;
plugin->finalizeOptionalMembersFnc =
(PRESTypePluginFinalizeOptionalMembersFunction)
HelloWorld_finalize_optional_members;
plugin->serializeFnc =
(PRESTypePluginSerializeFunction) PRESTypePlugin_interpretedSerialize;
plugin->deserializeFnc =
(PRESTypePluginDeserializeFunction) PRESTypePlugin_interpretedDeserializeWithAlloc;
plugin->getSerializedSampleMaxSizeFnc =
(PRESTypePluginGetSerializedSampleMaxSizeFunction)
HelloWorldPlugin_get_serialized_sample_max_size;
plugin->getSerializedSampleMinSizeFnc =
(PRESTypePluginGetSerializedSampleMinSizeFunction)
PRESTypePlugin_interpretedGetSerializedSampleMinSize;
plugin->getDeserializedSampleMaxSizeFnc = NULL;
plugin->getSampleFnc =
(PRESTypePluginGetSampleFunction)
HelloWorldPlugin_get_sample;
plugin->returnSampleFnc =
(PRESTypePluginReturnSampleFunction)
HelloWorldPlugin_return_sample;
plugin->getKeyKindFnc =
(PRESTypePluginGetKeyKindFunction)
HelloWorldPlugin_get_key_kind;
/* These functions are only used for keyed types. As this is not a keyed
type they are all set to NULL
*/
plugin->serializeKeyFnc = NULL ;
plugin->deserializeKeyFnc = NULL;
plugin->getKeyFnc = NULL;
plugin->returnKeyFnc = NULL;
plugin->instanceToKeyFnc = NULL;
plugin->keyToInstanceFnc = NULL;
plugin->getSerializedKeyMaxSizeFnc = NULL;
plugin->instanceToKeyHashFnc = NULL;
plugin->serializedSampleToKeyHashFnc = NULL;
plugin->serializedKeyToKeyHashFnc = NULL;
#ifdef NDDS_STANDALONE_TYPE
plugin->typeCode = NULL;
#else
plugin->typeCode = (struct RTICdrTypeCode *)HelloWorld_get_typecode();
#endif
plugin->languageKind = PRES_TYPEPLUGIN_CPP_LANG;
/* Serialized buffer */
plugin->getBuffer =
(PRESTypePluginGetBufferFunction)
HelloWorldPlugin_get_buffer;
plugin->returnBuffer =
(PRESTypePluginReturnBufferFunction)
HelloWorldPlugin_return_buffer;
plugin->getBufferWithParams = NULL;
plugin->returnBufferWithParams = NULL;
plugin->getSerializedSampleSizeFnc =
(PRESTypePluginGetSerializedSampleSizeFunction)
PRESTypePlugin_interpretedGetSerializedSampleSize;
plugin->getWriterLoanedSampleFnc = NULL;
plugin->returnWriterLoanedSampleFnc = NULL;
plugin->returnWriterLoanedSampleFromCookieFnc = NULL;
plugin->validateWriterLoanedSampleFnc = NULL;
plugin->setWriterLoanedSampleSerializedStateFnc = NULL;
plugin->endpointTypeName = HelloWorldTYPENAME;
plugin->isMetpType = RTI_FALSE;
return plugin;
}
void
HelloWorldPlugin_delete(struct PRESTypePlugin *plugin)
{
RTIOsapiHeap_freeStructure(plugin);
}
#undef RTI_CDR_CURRENT_SUBMODULE