You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
765 lines
23 KiB
C++
765 lines
23 KiB
C++
// Copyright 2016 Proyectos y Sistemas de Mantenimiento SL (eProsima).
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
/*!
|
|
* @file SystemPubSubTypes.cpp
|
|
* This header file contains the implementation of the serialization functions.
|
|
*
|
|
* This file was generated by the tool fastddsgen.
|
|
*/
|
|
|
|
#include "SystemPubSubTypes.hpp"
|
|
|
|
#include <fastdds/dds/log/Log.hpp>
|
|
#include <fastdds/rtps/common/CdrSerialization.hpp>
|
|
|
|
#include "SystemCdrAux.hpp"
|
|
#include "SystemTypeObjectSupport.hpp"
|
|
|
|
using SerializedPayload_t = eprosima::fastdds::rtps::SerializedPayload_t;
|
|
using InstanceHandle_t = eprosima::fastdds::rtps::InstanceHandle_t;
|
|
using DataRepresentationId_t = eprosima::fastdds::dds::DataRepresentationId_t;
|
|
|
|
PrintReqPubSubType::PrintReqPubSubType()
|
|
{
|
|
set_name("PrintReq");
|
|
uint32_t type_size = PrintReq_max_cdr_typesize;
|
|
type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
|
|
max_serialized_type_size = type_size + 4; /*encapsulation*/
|
|
is_compute_key_provided = false;
|
|
uint32_t key_length = PrintReq_max_key_cdr_typesize > 16 ? PrintReq_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
PrintReqPubSubType::~PrintReqPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool PrintReqPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const PrintReq* p_type = static_cast<const PrintReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
ser.set_encoding_flag(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR :
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
|
|
|
|
try
|
|
{
|
|
// Serialize encapsulation
|
|
ser.serialize_encapsulation();
|
|
// Serialize the object.
|
|
ser << *p_type;
|
|
ser.set_dds_cdr_options({0,0});
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the serialized length
|
|
payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
|
|
return true;
|
|
}
|
|
|
|
bool PrintReqPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
PrintReq* p_type = static_cast<PrintReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
|
|
|
|
// Object that deserializes the data.
|
|
eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
|
|
|
|
// Deserialize encapsulation.
|
|
deser.read_encapsulation();
|
|
payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
|
|
// Deserialize the object.
|
|
deser >> *p_type;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t PrintReqPubSubType::calculate_serialized_size(
|
|
const void* const data,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
try
|
|
{
|
|
eprosima::fastcdr::CdrSizeCalculator calculator(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
size_t current_alignment {0};
|
|
return static_cast<uint32_t>(calculator.calculate_serialized_size(
|
|
*static_cast<const PrintReq*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* PrintReqPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new PrintReq());
|
|
}
|
|
|
|
void PrintReqPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<PrintReq*>(data));
|
|
}
|
|
|
|
bool PrintReqPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
PrintReq data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool PrintReqPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const PrintReq* p_type = static_cast<const PrintReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
PrintReq_max_key_cdr_typesize);
|
|
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
|
|
eprosima::fastcdr::serialize_key(ser, *p_type);
|
|
if (force_md5 || PrintReq_max_key_cdr_typesize > 16)
|
|
{
|
|
md5_.init();
|
|
md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
|
|
md5_.finalize();
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = md5_.digest[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = key_buffer_[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PrintReqPubSubType::register_type_object_representation()
|
|
{
|
|
register_PrintReq_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
PrintRspPubSubType::PrintRspPubSubType()
|
|
{
|
|
set_name("PrintRsp");
|
|
uint32_t type_size = PrintRsp_max_cdr_typesize;
|
|
type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
|
|
max_serialized_type_size = type_size + 4; /*encapsulation*/
|
|
is_compute_key_provided = false;
|
|
uint32_t key_length = PrintRsp_max_key_cdr_typesize > 16 ? PrintRsp_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
PrintRspPubSubType::~PrintRspPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool PrintRspPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const PrintRsp* p_type = static_cast<const PrintRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
ser.set_encoding_flag(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR :
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
|
|
|
|
try
|
|
{
|
|
// Serialize encapsulation
|
|
ser.serialize_encapsulation();
|
|
// Serialize the object.
|
|
ser << *p_type;
|
|
ser.set_dds_cdr_options({0,0});
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the serialized length
|
|
payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
|
|
return true;
|
|
}
|
|
|
|
bool PrintRspPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
PrintRsp* p_type = static_cast<PrintRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
|
|
|
|
// Object that deserializes the data.
|
|
eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
|
|
|
|
// Deserialize encapsulation.
|
|
deser.read_encapsulation();
|
|
payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
|
|
// Deserialize the object.
|
|
deser >> *p_type;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t PrintRspPubSubType::calculate_serialized_size(
|
|
const void* const data,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
try
|
|
{
|
|
eprosima::fastcdr::CdrSizeCalculator calculator(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
size_t current_alignment {0};
|
|
return static_cast<uint32_t>(calculator.calculate_serialized_size(
|
|
*static_cast<const PrintRsp*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* PrintRspPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new PrintRsp());
|
|
}
|
|
|
|
void PrintRspPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<PrintRsp*>(data));
|
|
}
|
|
|
|
bool PrintRspPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
PrintRsp data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool PrintRspPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const PrintRsp* p_type = static_cast<const PrintRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
PrintRsp_max_key_cdr_typesize);
|
|
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
|
|
eprosima::fastcdr::serialize_key(ser, *p_type);
|
|
if (force_md5 || PrintRsp_max_key_cdr_typesize > 16)
|
|
{
|
|
md5_.init();
|
|
md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
|
|
md5_.finalize();
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = md5_.digest[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = key_buffer_[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void PrintRspPubSubType::register_type_object_representation()
|
|
{
|
|
register_PrintRsp_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
WeighReqPubSubType::WeighReqPubSubType()
|
|
{
|
|
set_name("WeighReq");
|
|
uint32_t type_size = WeighReq_max_cdr_typesize;
|
|
type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
|
|
max_serialized_type_size = type_size + 4; /*encapsulation*/
|
|
is_compute_key_provided = false;
|
|
uint32_t key_length = WeighReq_max_key_cdr_typesize > 16 ? WeighReq_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
WeighReqPubSubType::~WeighReqPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool WeighReqPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const WeighReq* p_type = static_cast<const WeighReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
ser.set_encoding_flag(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR :
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
|
|
|
|
try
|
|
{
|
|
// Serialize encapsulation
|
|
ser.serialize_encapsulation();
|
|
// Serialize the object.
|
|
ser << *p_type;
|
|
ser.set_dds_cdr_options({0,0});
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the serialized length
|
|
payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
|
|
return true;
|
|
}
|
|
|
|
bool WeighReqPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
WeighReq* p_type = static_cast<WeighReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
|
|
|
|
// Object that deserializes the data.
|
|
eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
|
|
|
|
// Deserialize encapsulation.
|
|
deser.read_encapsulation();
|
|
payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
|
|
// Deserialize the object.
|
|
deser >> *p_type;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t WeighReqPubSubType::calculate_serialized_size(
|
|
const void* const data,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
try
|
|
{
|
|
eprosima::fastcdr::CdrSizeCalculator calculator(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
size_t current_alignment {0};
|
|
return static_cast<uint32_t>(calculator.calculate_serialized_size(
|
|
*static_cast<const WeighReq*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* WeighReqPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new WeighReq());
|
|
}
|
|
|
|
void WeighReqPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<WeighReq*>(data));
|
|
}
|
|
|
|
bool WeighReqPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
WeighReq data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool WeighReqPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const WeighReq* p_type = static_cast<const WeighReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
WeighReq_max_key_cdr_typesize);
|
|
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
|
|
eprosima::fastcdr::serialize_key(ser, *p_type);
|
|
if (force_md5 || WeighReq_max_key_cdr_typesize > 16)
|
|
{
|
|
md5_.init();
|
|
md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
|
|
md5_.finalize();
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = md5_.digest[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = key_buffer_[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void WeighReqPubSubType::register_type_object_representation()
|
|
{
|
|
register_WeighReq_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
WeighRspPubSubType::WeighRspPubSubType()
|
|
{
|
|
set_name("WeighRsp");
|
|
uint32_t type_size = WeighRsp_max_cdr_typesize;
|
|
type_size += static_cast<uint32_t>(eprosima::fastcdr::Cdr::alignment(type_size, 4)); /* possible submessage alignment */
|
|
max_serialized_type_size = type_size + 4; /*encapsulation*/
|
|
is_compute_key_provided = false;
|
|
uint32_t key_length = WeighRsp_max_key_cdr_typesize > 16 ? WeighRsp_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
WeighRspPubSubType::~WeighRspPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool WeighRspPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const WeighRsp* p_type = static_cast<const WeighRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.max_size);
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN,
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 : eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
payload.encapsulation = ser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
ser.set_encoding_flag(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR :
|
|
eprosima::fastcdr::EncodingAlgorithmFlag::DELIMIT_CDR2);
|
|
|
|
try
|
|
{
|
|
// Serialize encapsulation
|
|
ser.serialize_encapsulation();
|
|
// Serialize the object.
|
|
ser << *p_type;
|
|
ser.set_dds_cdr_options({0,0});
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Get the serialized length
|
|
payload.length = static_cast<uint32_t>(ser.get_serialized_data_length());
|
|
return true;
|
|
}
|
|
|
|
bool WeighRspPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
WeighRsp* p_type = static_cast<WeighRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(payload.data), payload.length);
|
|
|
|
// Object that deserializes the data.
|
|
eprosima::fastcdr::Cdr deser(fastbuffer, eprosima::fastcdr::Cdr::DEFAULT_ENDIAN);
|
|
|
|
// Deserialize encapsulation.
|
|
deser.read_encapsulation();
|
|
payload.encapsulation = deser.endianness() == eprosima::fastcdr::Cdr::BIG_ENDIANNESS ? CDR_BE : CDR_LE;
|
|
|
|
// Deserialize the object.
|
|
deser >> *p_type;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t WeighRspPubSubType::calculate_serialized_size(
|
|
const void* const data,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
try
|
|
{
|
|
eprosima::fastcdr::CdrSizeCalculator calculator(
|
|
data_representation == DataRepresentationId_t::XCDR_DATA_REPRESENTATION ?
|
|
eprosima::fastcdr::CdrVersion::XCDRv1 :eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
size_t current_alignment {0};
|
|
return static_cast<uint32_t>(calculator.calculate_serialized_size(
|
|
*static_cast<const WeighRsp*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* WeighRspPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new WeighRsp());
|
|
}
|
|
|
|
void WeighRspPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<WeighRsp*>(data));
|
|
}
|
|
|
|
bool WeighRspPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
WeighRsp data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool WeighRspPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const WeighRsp* p_type = static_cast<const WeighRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
WeighRsp_max_key_cdr_typesize);
|
|
|
|
// Object that serializes the data.
|
|
eprosima::fastcdr::Cdr ser(fastbuffer, eprosima::fastcdr::Cdr::BIG_ENDIANNESS, eprosima::fastcdr::CdrVersion::XCDRv2);
|
|
ser.set_encoding_flag(eprosima::fastcdr::EncodingAlgorithmFlag::PLAIN_CDR2);
|
|
eprosima::fastcdr::serialize_key(ser, *p_type);
|
|
if (force_md5 || WeighRsp_max_key_cdr_typesize > 16)
|
|
{
|
|
md5_.init();
|
|
md5_.update(key_buffer_, static_cast<unsigned int>(ser.get_serialized_data_length()));
|
|
md5_.finalize();
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = md5_.digest[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (uint8_t i = 0; i < 16; ++i)
|
|
{
|
|
handle.value[i] = key_buffer_[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void WeighRspPubSubType::register_type_object_representation()
|
|
{
|
|
register_WeighRsp_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
|
|
// Include auxiliary functions like for serializing/deserializing.
|
|
#include "SystemCdrAux.ipp"
|