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.
1496 lines
52 KiB
C++
1496 lines
52 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;
|
|
|
|
namespace InternalSystem {
|
|
LicencePlateReqPubSubType::LicencePlateReqPubSubType()
|
|
{
|
|
set_name("InternalSystem::LicencePlateReq");
|
|
uint32_t type_size = InternalSystem_LicencePlateReq_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 = InternalSystem_LicencePlateReq_max_key_cdr_typesize > 16 ? InternalSystem_LicencePlateReq_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
LicencePlateReqPubSubType::~LicencePlateReqPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool LicencePlateReqPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const LicencePlateReq* p_type = static_cast<const LicencePlateReq*>(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 LicencePlateReqPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
LicencePlateReq* p_type = static_cast<LicencePlateReq*>(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 LicencePlateReqPubSubType::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 LicencePlateReq*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* LicencePlateReqPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new LicencePlateReq());
|
|
}
|
|
|
|
void LicencePlateReqPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<LicencePlateReq*>(data));
|
|
}
|
|
|
|
bool LicencePlateReqPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LicencePlateReq data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LicencePlateReqPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const LicencePlateReq* p_type = static_cast<const LicencePlateReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
InternalSystem_LicencePlateReq_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 || InternalSystem_LicencePlateReq_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 LicencePlateReqPubSubType::register_type_object_representation()
|
|
{
|
|
register_LicencePlateReq_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
LicencePlateRspPubSubType::LicencePlateRspPubSubType()
|
|
{
|
|
set_name("InternalSystem::LicencePlateRsp");
|
|
uint32_t type_size = InternalSystem_LicencePlateRsp_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 = InternalSystem_LicencePlateRsp_max_key_cdr_typesize > 16 ? InternalSystem_LicencePlateRsp_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
LicencePlateRspPubSubType::~LicencePlateRspPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool LicencePlateRspPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const LicencePlateRsp* p_type = static_cast<const LicencePlateRsp*>(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 LicencePlateRspPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
LicencePlateRsp* p_type = static_cast<LicencePlateRsp*>(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 LicencePlateRspPubSubType::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 LicencePlateRsp*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* LicencePlateRspPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new LicencePlateRsp());
|
|
}
|
|
|
|
void LicencePlateRspPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<LicencePlateRsp*>(data));
|
|
}
|
|
|
|
bool LicencePlateRspPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
LicencePlateRsp data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LicencePlateRspPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const LicencePlateRsp* p_type = static_cast<const LicencePlateRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
InternalSystem_LicencePlateRsp_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 || InternalSystem_LicencePlateRsp_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 LicencePlateRspPubSubType::register_type_object_representation()
|
|
{
|
|
register_LicencePlateRsp_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
PrintReqPubSubType::PrintReqPubSubType()
|
|
{
|
|
set_name("InternalSystem::PrintReq");
|
|
uint32_t type_size = InternalSystem_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 = InternalSystem_PrintReq_max_key_cdr_typesize > 16 ? InternalSystem_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_),
|
|
InternalSystem_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 || InternalSystem_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("InternalSystem::PrintRsp");
|
|
uint32_t type_size = InternalSystem_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 = InternalSystem_PrintRsp_max_key_cdr_typesize > 16 ? InternalSystem_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_),
|
|
InternalSystem_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 || InternalSystem_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("InternalSystem::WeighReq");
|
|
uint32_t type_size = InternalSystem_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 = InternalSystem_WeighReq_max_key_cdr_typesize > 16 ? InternalSystem_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_),
|
|
InternalSystem_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 || InternalSystem_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("InternalSystem::WeighRsp");
|
|
uint32_t type_size = InternalSystem_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 = InternalSystem_WeighRsp_max_key_cdr_typesize > 16 ? InternalSystem_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_),
|
|
InternalSystem_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 || InternalSystem_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_);
|
|
}
|
|
|
|
IoCtrlReqPubSubType::IoCtrlReqPubSubType()
|
|
{
|
|
set_name("InternalSystem::IoCtrlReq");
|
|
uint32_t type_size = InternalSystem_IoCtrlReq_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 = InternalSystem_IoCtrlReq_max_key_cdr_typesize > 16 ? InternalSystem_IoCtrlReq_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
IoCtrlReqPubSubType::~IoCtrlReqPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool IoCtrlReqPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const IoCtrlReq* p_type = static_cast<const IoCtrlReq*>(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 IoCtrlReqPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
IoCtrlReq* p_type = static_cast<IoCtrlReq*>(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 IoCtrlReqPubSubType::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 IoCtrlReq*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* IoCtrlReqPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new IoCtrlReq());
|
|
}
|
|
|
|
void IoCtrlReqPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<IoCtrlReq*>(data));
|
|
}
|
|
|
|
bool IoCtrlReqPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
IoCtrlReq data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IoCtrlReqPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const IoCtrlReq* p_type = static_cast<const IoCtrlReq*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
InternalSystem_IoCtrlReq_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 || InternalSystem_IoCtrlReq_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 IoCtrlReqPubSubType::register_type_object_representation()
|
|
{
|
|
register_IoCtrlReq_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
IoCtrlRspPubSubType::IoCtrlRspPubSubType()
|
|
{
|
|
set_name("InternalSystem::IoCtrlRsp");
|
|
uint32_t type_size = InternalSystem_IoCtrlRsp_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 = InternalSystem_IoCtrlRsp_max_key_cdr_typesize > 16 ? InternalSystem_IoCtrlRsp_max_key_cdr_typesize : 16;
|
|
key_buffer_ = reinterpret_cast<unsigned char*>(malloc(key_length));
|
|
memset(key_buffer_, 0, key_length);
|
|
}
|
|
|
|
IoCtrlRspPubSubType::~IoCtrlRspPubSubType()
|
|
{
|
|
if (key_buffer_ != nullptr)
|
|
{
|
|
free(key_buffer_);
|
|
}
|
|
}
|
|
|
|
bool IoCtrlRspPubSubType::serialize(
|
|
const void* const data,
|
|
SerializedPayload_t& payload,
|
|
DataRepresentationId_t data_representation)
|
|
{
|
|
const IoCtrlRsp* p_type = static_cast<const IoCtrlRsp*>(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 IoCtrlRspPubSubType::deserialize(
|
|
SerializedPayload_t& payload,
|
|
void* data)
|
|
{
|
|
try
|
|
{
|
|
// Convert DATA to pointer of your type
|
|
IoCtrlRsp* p_type = static_cast<IoCtrlRsp*>(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 IoCtrlRspPubSubType::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 IoCtrlRsp*>(data), current_alignment)) +
|
|
4u /*encapsulation*/;
|
|
}
|
|
catch (eprosima::fastcdr::exception::Exception& /*exception*/)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void* IoCtrlRspPubSubType::create_data()
|
|
{
|
|
return reinterpret_cast<void*>(new IoCtrlRsp());
|
|
}
|
|
|
|
void IoCtrlRspPubSubType::delete_data(
|
|
void* data)
|
|
{
|
|
delete(reinterpret_cast<IoCtrlRsp*>(data));
|
|
}
|
|
|
|
bool IoCtrlRspPubSubType::compute_key(
|
|
SerializedPayload_t& payload,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
IoCtrlRsp data;
|
|
if (deserialize(payload, static_cast<void*>(&data)))
|
|
{
|
|
return compute_key(static_cast<void*>(&data), handle, force_md5);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IoCtrlRspPubSubType::compute_key(
|
|
const void* const data,
|
|
InstanceHandle_t& handle,
|
|
bool force_md5)
|
|
{
|
|
if (!is_compute_key_provided)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const IoCtrlRsp* p_type = static_cast<const IoCtrlRsp*>(data);
|
|
|
|
// Object that manages the raw buffer.
|
|
eprosima::fastcdr::FastBuffer fastbuffer(reinterpret_cast<char*>(key_buffer_),
|
|
InternalSystem_IoCtrlRsp_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 || InternalSystem_IoCtrlRsp_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 IoCtrlRspPubSubType::register_type_object_representation()
|
|
{
|
|
register_IoCtrlRsp_type_identifier(type_identifiers_);
|
|
}
|
|
|
|
} // namespace InternalSystem
|
|
|
|
|
|
// Include auxiliary functions like for serializing/deserializing.
|
|
#include "SystemCdrAux.ipp"
|