nils/cyphal_hardware_interface
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
cyphal_hardware_interface/hardware/include/uavcan/node/GetInfo_1_0.h
Nils Schulte df45978fa4 wip
2025-07-19 23:39:07 +02:00

672 lines
33 KiB
C
Raw Blame History

// This is an AUTO-GENERATED Cyphal DSDL data type implementation. Curious? See https://opencyphal.org.
// You shouldn't attempt to edit this file.
//
// Checking this file under version control is not recommended unless it is used as part of a high-SIL
// safety-critical codebase. The typical usage scenario is to generate it as part of the build process.
//
// To avoid conflicts with definitions given in the source DSDL file, all entities created by the code generator
// are named with an underscore at the end, like foo_bar_().
//
// Generator: nunavut-2.3.1 (serialization was enabled)
// Source file: /home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl
// Generated at: 2025-07-17 18:00:19.089089 UTC
// Is deprecated: no
// Fixed port-ID: 430
// Full name: uavcan.node.GetInfo
// Version: 1.0
//
// Platform
// python_implementation: CPython
// python_version: 3.13.5
// python_release_level: final
// python_build: ('main', 'Jun 21 2025 09:35:00')
// python_compiler: GCC 15.1.1 20250425
// python_revision:
// python_xoptions: {}
// runtime_platform: Linux-6.15.6-arch1-1-x86_64-with-glibc2.41
//
// Language Options
// target_endianness: any
// omit_float_serialization_support: False
// enable_serialization_asserts: True
// enable_override_variable_array_capacity: False
// cast_format: (({type}) {value})
#ifndef UAVCAN_NODE_GET_INFO_1_0_INCLUDED_
#define UAVCAN_NODE_GET_INFO_1_0_INCLUDED_
#include <nunavut/support/serialization.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <uavcan/node/Version_1_0.h>
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_TARGET_ENDIANNESS == 1693710260,
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl is trying to use a serialization library that was compiled with "
"different language options. This is dangerous and therefore not allowed." );
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_OMIT_FLOAT_SERIALIZATION_SUPPORT == 0,
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl is trying to use a serialization library that was compiled with "
"different language options. This is dangerous and therefore not allowed." );
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_ENABLE_SERIALIZATION_ASSERTS == 1,
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl is trying to use a serialization library that was compiled with "
"different language options. This is dangerous and therefore not allowed." );
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_ENABLE_OVERRIDE_VARIABLE_ARRAY_CAPACITY == 0,
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl is trying to use a serialization library that was compiled with "
"different language options. This is dangerous and therefore not allowed." );
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_CAST_FORMAT == 2368206204,
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/node/430.GetInfo.1.0.dsdl is trying to use a serialization library that was compiled with "
"different language options. This is dangerous and therefore not allowed." );
#ifdef __cplusplus
extern "C" {
#endif
#define uavcan_node_GetInfo_1_0_HAS_FIXED_PORT_ID_ true
#define uavcan_node_GetInfo_1_0_FIXED_PORT_ID_ 430U
// +-------------------------------------------------------------------------------------------------------------------+
// | uavcan.node.GetInfo.1.0
// +-------------------------------------------------------------------------------------------------------------------+
#define uavcan_node_GetInfo_1_0_FULL_NAME_ "uavcan.node.GetInfo"
#define uavcan_node_GetInfo_1_0_FULL_NAME_AND_VERSION_ "uavcan.node.GetInfo.1.0"
// +-------------------------------------------------------------------------------------------------------------------+
// | uavcan.node.GetInfo.Request.1.0
// +-------------------------------------------------------------------------------------------------------------------+
#define uavcan_node_GetInfo_Request_1_0_FULL_NAME_ "uavcan.node.GetInfo.Request"
#define uavcan_node_GetInfo_Request_1_0_FULL_NAME_AND_VERSION_ "uavcan.node.GetInfo.Request.1.0"
/// Extent is the minimum amount of memory required to hold any serialized representation of any compatible
/// version of the data type; or, on other words, it is the the maximum possible size of received objects of this type.
/// The size is specified in bytes (rather than bits) because by definition, extent is an integer number of bytes long.
/// When allocating a deserialization (RX) buffer for this data type, it should be at least extent bytes large.
/// When allocating a serialization (TX) buffer, it is safe to use the size of the largest serialized representation
/// instead of the extent because it provides a tighter bound of the object size; it is safe because the concrete type
/// is always known during serialization (unlike deserialization). If not sure, use extent everywhere.
#define uavcan_node_GetInfo_Request_1_0_EXTENT_BYTES_ 0UL
#define uavcan_node_GetInfo_Request_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_ 0UL
static_assert(uavcan_node_GetInfo_Request_1_0_EXTENT_BYTES_ >= uavcan_node_GetInfo_Request_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_,
"Internal constraint violation");
typedef struct
{
uint8_t _dummy_;
} uavcan_node_GetInfo_Request_1_0;
/// Serialize an instance into the provided buffer.
/// The lifetime of the resulting serialized representation is independent of the original instance.
/// This method may be slow for large objects (e.g., images, point clouds, radar samples), so in a later revision
/// we may define a zero-copy alternative that keeps references to the original object where possible.
///
/// @param obj The object to serialize.
///
/// @param buffer The destination buffer. There are no alignment requirements.
/// @see uavcan_node_GetInfo_Request_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_
///
/// @param inout_buffer_size_bytes When calling, this is a pointer to the size of the buffer in bytes.
/// Upon return this value will be updated with the size of the constructed serialized
/// representation (in bytes); this value is then to be passed over to the transport
/// layer. In case of error this value is undefined.
///
/// @returns Negative on error, zero on success.
static inline int8_t uavcan_node_GetInfo_Request_1_0_serialize_(
const uavcan_node_GetInfo_Request_1_0* const obj, uint8_t* const buffer, size_t* const inout_buffer_size_bytes)
{
if ((obj == NULL) || (buffer == NULL) || (inout_buffer_size_bytes == NULL))
{
return -NUNAVUT_ERROR_INVALID_ARGUMENT;
}
*inout_buffer_size_bytes = 0U;
return NUNAVUT_SUCCESS;
}
/// Deserialize an instance from the provided buffer.
/// The lifetime of the resulting object is independent of the original buffer.
/// This method may be slow for large objects (e.g., images, point clouds, radar samples), so in a later revision
/// we may define a zero-copy alternative that keeps references to the original buffer where possible.
///
/// @param obj The object to update from the provided serialized representation.
///
/// @param buffer The source buffer containing the serialized representation. There are no alignment requirements.
/// If the buffer is shorter or longer than expected, it will be implicitly zero-extended or truncated,
/// respectively; see Specification for "implicit zero extension" and "implicit truncation" rules.
///
/// @param inout_buffer_size_bytes When calling, this is a pointer to the size of the supplied serialized
/// representation, in bytes. Upon return this value will be updated with the
/// size of the consumed fragment of the serialized representation (in bytes),
/// which may be smaller due to the implicit truncation rule, but it is guaranteed
/// to never exceed the original buffer size even if the implicit zero extension rule
/// was activated. In case of error this value is undefined.
///
/// @returns Negative on error, zero on success.
static inline int8_t uavcan_node_GetInfo_Request_1_0_deserialize_(
uavcan_node_GetInfo_Request_1_0* const out_obj, const uint8_t* buffer, size_t* const inout_buffer_size_bytes)
{
if ((out_obj == NULL) || (inout_buffer_size_bytes == NULL) || ((buffer == NULL) && (0 != *inout_buffer_size_bytes)))
{
return -NUNAVUT_ERROR_INVALID_ARGUMENT;
}
if (buffer == NULL)
{
buffer = (const uint8_t*)"";
}
*inout_buffer_size_bytes = 0U;
return NUNAVUT_SUCCESS;
}
/// Initialize an instance to default values. Does nothing if @param out_obj is NULL.
/// This function intentionally leaves inactive elements uninitialized; for example, members of a variable-length
/// array beyond its length are left uninitialized; aliased union memory that is not used by the first union field
/// is left uninitialized, etc. If full zero-initialization is desired, just use memset(&obj, 0, sizeof(obj)).
static inline void uavcan_node_GetInfo_Request_1_0_initialize_(uavcan_node_GetInfo_Request_1_0* const out_obj)
{
if (out_obj != NULL)
{
size_t size_bytes = 0;
const uint8_t buf = 0;
const int8_t err = uavcan_node_GetInfo_Request_1_0_deserialize_(out_obj, &buf, &size_bytes);
NUNAVUT_ASSERT(err >= 0);
(void) err;
}
}
// +-------------------------------------------------------------------------------------------------------------------+
// | uavcan.node.GetInfo.Response.1.0
// +-------------------------------------------------------------------------------------------------------------------+
#define uavcan_node_GetInfo_Response_1_0_FULL_NAME_ "uavcan.node.GetInfo.Response"
#define uavcan_node_GetInfo_Response_1_0_FULL_NAME_AND_VERSION_ "uavcan.node.GetInfo.Response.1.0"
/// Extent is the minimum amount of memory required to hold any serialized representation of any compatible
/// version of the data type; or, on other words, it is the the maximum possible size of received objects of this type.
/// The size is specified in bytes (rather than bits) because by definition, extent is an integer number of bytes long.
/// When allocating a deserialization (RX) buffer for this data type, it should be at least extent bytes large.
/// When allocating a serialization (TX) buffer, it is safe to use the size of the largest serialized representation
/// instead of the extent because it provides a tighter bound of the object size; it is safe because the concrete type
/// is always known during serialization (unlike deserialization). If not sure, use extent everywhere.
#define uavcan_node_GetInfo_Response_1_0_EXTENT_BYTES_ 448UL
#define uavcan_node_GetInfo_Response_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_ 313UL
static_assert(uavcan_node_GetInfo_Response_1_0_EXTENT_BYTES_ >= uavcan_node_GetInfo_Response_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_,
"Internal constraint violation");
/// Array metadata for: saturated uint8[16] unique_id
#define uavcan_node_GetInfo_Response_1_0_unique_id_ARRAY_CAPACITY_ 16U
#define uavcan_node_GetInfo_Response_1_0_unique_id_ARRAY_IS_VARIABLE_LENGTH_ false
/// Array metadata for: saturated uint8[<=50] name
#define uavcan_node_GetInfo_Response_1_0_name_ARRAY_CAPACITY_ 50U
#define uavcan_node_GetInfo_Response_1_0_name_ARRAY_IS_VARIABLE_LENGTH_ true
/// Array metadata for: saturated uint64[<=1] software_image_crc
#define uavcan_node_GetInfo_Response_1_0_software_image_crc_ARRAY_CAPACITY_ 1U
#define uavcan_node_GetInfo_Response_1_0_software_image_crc_ARRAY_IS_VARIABLE_LENGTH_ true
/// Array metadata for: saturated uint8[<=222] certificate_of_authenticity
#define uavcan_node_GetInfo_Response_1_0_certificate_of_authenticity_ARRAY_CAPACITY_ 222U
#define uavcan_node_GetInfo_Response_1_0_certificate_of_authenticity_ARRAY_IS_VARIABLE_LENGTH_ true
typedef struct
{
/// uavcan.node.Version.1.0 protocol_version
uavcan_node_Version_1_0 protocol_version;
/// uavcan.node.Version.1.0 hardware_version
uavcan_node_Version_1_0 hardware_version;
/// uavcan.node.Version.1.0 software_version
uavcan_node_Version_1_0 software_version;
/// saturated uint64 software_vcs_revision_id
uint64_t software_vcs_revision_id;
/// saturated uint8[16] unique_id
uint8_t unique_id[16];
/// saturated uint8[<=50] name
struct /// Array address equivalence guarantee: &elements[0] == &name
{
uint8_t elements[uavcan_node_GetInfo_Response_1_0_name_ARRAY_CAPACITY_];
size_t count;
} name;
/// saturated uint64[<=1] software_image_crc
struct /// Array address equivalence guarantee: &elements[0] == &software_image_crc
{
uint64_t elements[uavcan_node_GetInfo_Response_1_0_software_image_crc_ARRAY_CAPACITY_];
size_t count;
} software_image_crc;
/// saturated uint8[<=222] certificate_of_authenticity
struct /// Array address equivalence guarantee: &elements[0] == &certificate_of_authenticity
{
uint8_t elements[uavcan_node_GetInfo_Response_1_0_certificate_of_authenticity_ARRAY_CAPACITY_];
size_t count;
} certificate_of_authenticity;
} uavcan_node_GetInfo_Response_1_0;
/// Serialize an instance into the provided buffer.
/// The lifetime of the resulting serialized representation is independent of the original instance.
/// This method may be slow for large objects (e.g., images, point clouds, radar samples), so in a later revision
/// we may define a zero-copy alternative that keeps references to the original object where possible.
///
/// @param obj The object to serialize.
///
/// @param buffer The destination buffer. There are no alignment requirements.
/// @see uavcan_node_GetInfo_Response_1_0_SERIALIZATION_BUFFER_SIZE_BYTES_
///
/// @param inout_buffer_size_bytes When calling, this is a pointer to the size of the buffer in bytes.
/// Upon return this value will be updated with the size of the constructed serialized
/// representation (in bytes); this value is then to be passed over to the transport
/// layer. In case of error this value is undefined.
///
/// @returns Negative on error, zero on success.
static inline int8_t uavcan_node_GetInfo_Response_1_0_serialize_(
const uavcan_node_GetInfo_Response_1_0* const obj, uint8_t* const buffer, size_t* const inout_buffer_size_bytes)
{
if ((obj == NULL) || (buffer == NULL) || (inout_buffer_size_bytes == NULL))
{
return -NUNAVUT_ERROR_INVALID_ARGUMENT;
}
const size_t capacity_bytes = *inout_buffer_size_bytes;
if ((8U * (size_t) capacity_bytes) < 2504UL)
{
return -NUNAVUT_ERROR_SERIALIZATION_BUFFER_TOO_SMALL;
}
// Notice that fields that are not an integer number of bytes long may overrun the space allocated for them
// in the serialization buffer up to the next byte boundary. This is by design and is guaranteed to be safe.
size_t offset_bits = 0U;
{ // uavcan.node.Version.1.0 protocol_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 16ULL) <= (capacity_bytes * 8U));
size_t _size_bytes0_ = 2UL; // Nested object (max) size, in bytes.
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes0_) <= capacity_bytes);
int8_t _err0_ = uavcan_node_Version_1_0_serialize_(
&obj->protocol_version, &buffer[offset_bits / 8U], &_size_bytes0_);
if (_err0_ < 0)
{
return _err0_;
}
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
NUNAVUT_ASSERT((_size_bytes0_ * 8U) == 16ULL);
offset_bits += _size_bytes0_ * 8U; // Advance by the size of the nested object.
NUNAVUT_ASSERT(offset_bits <= (capacity_bytes * 8U));
}
if (offset_bits % 8U != 0U) // Pad to 8 bits. TODO: Eliminate redundant padding checks.
{
const uint8_t _pad0_ = (uint8_t)(8U - offset_bits % 8U);
NUNAVUT_ASSERT(_pad0_ > 0);
const int8_t _err1_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, _pad0_); // Optimize?
if (_err1_ < 0)
{
return _err1_;
}
offset_bits += _pad0_;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
}
{ // uavcan.node.Version.1.0 hardware_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 16ULL) <= (capacity_bytes * 8U));
size_t _size_bytes1_ = 2UL; // Nested object (max) size, in bytes.
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes1_) <= capacity_bytes);
int8_t _err2_ = uavcan_node_Version_1_0_serialize_(
&obj->hardware_version, &buffer[offset_bits / 8U], &_size_bytes1_);
if (_err2_ < 0)
{
return _err2_;
}
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
NUNAVUT_ASSERT((_size_bytes1_ * 8U) == 16ULL);
offset_bits += _size_bytes1_ * 8U; // Advance by the size of the nested object.
NUNAVUT_ASSERT(offset_bits <= (capacity_bytes * 8U));
}
if (offset_bits % 8U != 0U) // Pad to 8 bits. TODO: Eliminate redundant padding checks.
{
const uint8_t _pad1_ = (uint8_t)(8U - offset_bits % 8U);
NUNAVUT_ASSERT(_pad1_ > 0);
const int8_t _err3_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, _pad1_); // Optimize?
if (_err3_ < 0)
{
return _err3_;
}
offset_bits += _pad1_;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
}
{ // uavcan.node.Version.1.0 software_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 16ULL) <= (capacity_bytes * 8U));
size_t _size_bytes2_ = 2UL; // Nested object (max) size, in bytes.
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes2_) <= capacity_bytes);
int8_t _err4_ = uavcan_node_Version_1_0_serialize_(
&obj->software_version, &buffer[offset_bits / 8U], &_size_bytes2_);
if (_err4_ < 0)
{
return _err4_;
}
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
NUNAVUT_ASSERT((_size_bytes2_ * 8U) == 16ULL);
offset_bits += _size_bytes2_ * 8U; // Advance by the size of the nested object.
NUNAVUT_ASSERT(offset_bits <= (capacity_bytes * 8U));
}
{ // saturated uint64 software_vcs_revision_id
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 64ULL) <= (capacity_bytes * 8U));
// Saturation code not emitted -- native representation matches the serialized representation.
const int8_t _err5_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, obj->software_vcs_revision_id, 64U);
if (_err5_ < 0)
{
return _err5_;
}
offset_bits += 64U;
}
{ // saturated uint8[16] unique_id
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 128ULL) <= (capacity_bytes * 8U));
const size_t _origin0_ = offset_bits;
for (size_t _index0_ = 0U; _index0_ < 16UL; ++_index0_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 8ULL) <= (capacity_bytes * 8U));
// Saturation code not emitted -- native representation matches the serialized representation.
buffer[offset_bits / 8U] = (uint8_t)(obj->unique_id[_index0_]); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
}
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
NUNAVUT_ASSERT((offset_bits - _origin0_) == 128ULL);
(void) _origin0_;
}
{ // saturated uint8[<=50] name
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 408ULL) <= (capacity_bytes * 8U));
if (obj->name.count > 50)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
// Array length prefix: truncated uint8
buffer[offset_bits / 8U] = (uint8_t)(obj->name.count); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index1_ = 0U; _index1_ < obj->name.count; ++_index1_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 8ULL) <= (capacity_bytes * 8U));
// Saturation code not emitted -- native representation matches the serialized representation.
buffer[offset_bits / 8U] = (uint8_t)(obj->name.elements[_index1_]); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
}
}
{ // saturated uint64[<=1] software_image_crc
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 72ULL) <= (capacity_bytes * 8U));
if (obj->software_image_crc.count > 1)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
// Array length prefix: truncated uint8
buffer[offset_bits / 8U] = (uint8_t)(obj->software_image_crc.count); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index2_ = 0U; _index2_ < obj->software_image_crc.count; ++_index2_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 64ULL) <= (capacity_bytes * 8U));
// Saturation code not emitted -- native representation matches the serialized representation.
const int8_t _err6_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, obj->software_image_crc.elements[_index2_], 64U);
if (_err6_ < 0)
{
return _err6_;
}
offset_bits += 64U;
}
}
{ // saturated uint8[<=222] certificate_of_authenticity
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 1784ULL) <= (capacity_bytes * 8U));
if (obj->certificate_of_authenticity.count > 222)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
// Array length prefix: truncated uint8
buffer[offset_bits / 8U] = (uint8_t)(obj->certificate_of_authenticity.count); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index3_ = 0U; _index3_ < obj->certificate_of_authenticity.count; ++_index3_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT((offset_bits + 8ULL) <= (capacity_bytes * 8U));
// Saturation code not emitted -- native representation matches the serialized representation.
buffer[offset_bits / 8U] = (uint8_t)(obj->certificate_of_authenticity.elements[_index3_]); // C std, 6.3.1.3 Signed and unsigned integers
offset_bits += 8U;
}
}
if (offset_bits % 8U != 0U) // Pad to 8 bits. TODO: Eliminate redundant padding checks.
{
const uint8_t _pad2_ = (uint8_t)(8U - offset_bits % 8U);
NUNAVUT_ASSERT(_pad2_ > 0);
const int8_t _err7_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, _pad2_); // Optimize?
if (_err7_ < 0)
{
return _err7_;
}
offset_bits += _pad2_;
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
}
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
NUNAVUT_ASSERT(offset_bits >= 264ULL);
NUNAVUT_ASSERT(offset_bits <= 2504ULL);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
*inout_buffer_size_bytes = (size_t) (offset_bits / 8U);
return NUNAVUT_SUCCESS;
}
/// Deserialize an instance from the provided buffer.
/// The lifetime of the resulting object is independent of the original buffer.
/// This method may be slow for large objects (e.g., images, point clouds, radar samples), so in a later revision
/// we may define a zero-copy alternative that keeps references to the original buffer where possible.
///
/// @param obj The object to update from the provided serialized representation.
///
/// @param buffer The source buffer containing the serialized representation. There are no alignment requirements.
/// If the buffer is shorter or longer than expected, it will be implicitly zero-extended or truncated,
/// respectively; see Specification for "implicit zero extension" and "implicit truncation" rules.
///
/// @param inout_buffer_size_bytes When calling, this is a pointer to the size of the supplied serialized
/// representation, in bytes. Upon return this value will be updated with the
/// size of the consumed fragment of the serialized representation (in bytes),
/// which may be smaller due to the implicit truncation rule, but it is guaranteed
/// to never exceed the original buffer size even if the implicit zero extension rule
/// was activated. In case of error this value is undefined.
///
/// @returns Negative on error, zero on success.
static inline int8_t uavcan_node_GetInfo_Response_1_0_deserialize_(
uavcan_node_GetInfo_Response_1_0* const out_obj, const uint8_t* buffer, size_t* const inout_buffer_size_bytes)
{
if ((out_obj == NULL) || (inout_buffer_size_bytes == NULL) || ((buffer == NULL) && (0 != *inout_buffer_size_bytes)))
{
return -NUNAVUT_ERROR_INVALID_ARGUMENT;
}
if (buffer == NULL)
{
buffer = (const uint8_t*)"";
}
const size_t capacity_bytes = *inout_buffer_size_bytes;
const size_t capacity_bits = capacity_bytes * (size_t) 8U;
size_t offset_bits = 0U;
// uavcan.node.Version.1.0 protocol_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
{
size_t _size_bytes3_ = (size_t)(capacity_bytes - nunavutChooseMin((offset_bits / 8U), capacity_bytes));
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
const int8_t _err8_ = uavcan_node_Version_1_0_deserialize_(
&out_obj->protocol_version, &buffer[offset_bits / 8U], &_size_bytes3_);
if (_err8_ < 0)
{
return _err8_;
}
offset_bits += _size_bytes3_ * 8U; // Advance by the size of the nested serialized representation.
}
offset_bits = (offset_bits + 7U) & ~(size_t) 7U; // Align on 8 bits.
// uavcan.node.Version.1.0 hardware_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
{
size_t _size_bytes4_ = (size_t)(capacity_bytes - nunavutChooseMin((offset_bits / 8U), capacity_bytes));
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
const int8_t _err9_ = uavcan_node_Version_1_0_deserialize_(
&out_obj->hardware_version, &buffer[offset_bits / 8U], &_size_bytes4_);
if (_err9_ < 0)
{
return _err9_;
}
offset_bits += _size_bytes4_ * 8U; // Advance by the size of the nested serialized representation.
}
offset_bits = (offset_bits + 7U) & ~(size_t) 7U; // Align on 8 bits.
// uavcan.node.Version.1.0 software_version
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
{
size_t _size_bytes5_ = (size_t)(capacity_bytes - nunavutChooseMin((offset_bits / 8U), capacity_bytes));
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
const int8_t _err10_ = uavcan_node_Version_1_0_deserialize_(
&out_obj->software_version, &buffer[offset_bits / 8U], &_size_bytes5_);
if (_err10_ < 0)
{
return _err10_;
}
offset_bits += _size_bytes5_ * 8U; // Advance by the size of the nested serialized representation.
}
// saturated uint64 software_vcs_revision_id
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
out_obj->software_vcs_revision_id = nunavutGetU64(&buffer[0], capacity_bytes, offset_bits, 64);
offset_bits += 64U;
// saturated uint8[16] unique_id
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index4_ = 0U; _index4_ < 16UL; ++_index4_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->unique_id[_index4_] = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->unique_id[_index4_] = 0U;
}
offset_bits += 8U;
}
// saturated uint8[<=50] name
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
// Array length prefix: truncated uint8
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->name.count = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->name.count = 0U;
}
offset_bits += 8U;
if (out_obj->name.count > 50U)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index5_ = 0U; _index5_ < out_obj->name.count; ++_index5_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->name.elements[_index5_] = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->name.elements[_index5_] = 0U;
}
offset_bits += 8U;
}
// saturated uint64[<=1] software_image_crc
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
// Array length prefix: truncated uint8
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->software_image_crc.count = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->software_image_crc.count = 0U;
}
offset_bits += 8U;
if (out_obj->software_image_crc.count > 1U)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index6_ = 0U; _index6_ < out_obj->software_image_crc.count; ++_index6_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
out_obj->software_image_crc.elements[_index6_] = nunavutGetU64(&buffer[0], capacity_bytes, offset_bits, 64);
offset_bits += 64U;
}
// saturated uint8[<=222] certificate_of_authenticity
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
// Array length prefix: truncated uint8
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->certificate_of_authenticity.count = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->certificate_of_authenticity.count = 0U;
}
offset_bits += 8U;
if (out_obj->certificate_of_authenticity.count > 222U)
{
return -NUNAVUT_ERROR_REPRESENTATION_BAD_ARRAY_LENGTH;
}
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
for (size_t _index7_ = 0U; _index7_ < out_obj->certificate_of_authenticity.count; ++_index7_)
{
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
if ((offset_bits + 8U) <= capacity_bits)
{
out_obj->certificate_of_authenticity.elements[_index7_] = buffer[offset_bits / 8U] & 255U;
}
else
{
out_obj->certificate_of_authenticity.elements[_index7_] = 0U;
}
offset_bits += 8U;
}
offset_bits = (offset_bits + 7U) & ~(size_t) 7U; // Align on 8 bits.
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
*inout_buffer_size_bytes = (size_t) (nunavutChooseMin(offset_bits, capacity_bits) / 8U);
NUNAVUT_ASSERT(capacity_bytes >= *inout_buffer_size_bytes);
return NUNAVUT_SUCCESS;
}
/// Initialize an instance to default values. Does nothing if @param out_obj is NULL.
/// This function intentionally leaves inactive elements uninitialized; for example, members of a variable-length
/// array beyond its length are left uninitialized; aliased union memory that is not used by the first union field
/// is left uninitialized, etc. If full zero-initialization is desired, just use memset(&obj, 0, sizeof(obj)).
static inline void uavcan_node_GetInfo_Response_1_0_initialize_(uavcan_node_GetInfo_Response_1_0* const out_obj)
{
if (out_obj != NULL)
{
size_t size_bytes = 0;
const uint8_t buf = 0;
const int8_t err = uavcan_node_GetInfo_Response_1_0_deserialize_(out_obj, &buf, &size_bytes);
NUNAVUT_ASSERT(err >= 0);
(void) err;
}
}
#ifdef __cplusplus
}
#endif
#endif // UAVCAN_NODE_GET_INFO_1_0_INCLUDED_
Reference in New Issue View Git Blame Copy Permalink