521 lines
26 KiB
C
521 lines
26 KiB
C
// 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/file/407.Modify.1.1.dsdl
|
|
// Generated at: 2025-07-17 18:00:18.722941 UTC
|
|
// Is deprecated: no
|
|
// Fixed port-ID: 407
|
|
// Full name: uavcan.file.Modify
|
|
// Version: 1.1
|
|
//
|
|
// 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_FILE_MODIFY_1_1_INCLUDED_
|
|
#define UAVCAN_FILE_MODIFY_1_1_INCLUDED_
|
|
|
|
#include <nunavut/support/serialization.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <uavcan/file/Error_1_0.h>
|
|
#include <uavcan/file/Path_2_0.h>
|
|
|
|
static_assert( NUNAVUT_SUPPORT_LANGUAGE_OPTION_TARGET_ENDIANNESS == 1693710260,
|
|
"/home/nils/development/N17BLDC/fw/.pio/libdeps/nilsdriverv1/public_regulated_data_types/uavcan/file/407.Modify.1.1.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/file/407.Modify.1.1.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/file/407.Modify.1.1.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/file/407.Modify.1.1.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/file/407.Modify.1.1.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_file_Modify_1_1_HAS_FIXED_PORT_ID_ true
|
|
#define uavcan_file_Modify_1_1_FIXED_PORT_ID_ 407U
|
|
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
// | uavcan.file.Modify.1.1
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
#define uavcan_file_Modify_1_1_FULL_NAME_ "uavcan.file.Modify"
|
|
#define uavcan_file_Modify_1_1_FULL_NAME_AND_VERSION_ "uavcan.file.Modify.1.1"
|
|
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
// | uavcan.file.Modify.Request.1.1
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
#define uavcan_file_Modify_Request_1_1_FULL_NAME_ "uavcan.file.Modify.Request"
|
|
#define uavcan_file_Modify_Request_1_1_FULL_NAME_AND_VERSION_ "uavcan.file.Modify.Request.1.1"
|
|
|
|
/// 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_file_Modify_Request_1_1_EXTENT_BYTES_ 600UL
|
|
#define uavcan_file_Modify_Request_1_1_SERIALIZATION_BUFFER_SIZE_BYTES_ 516UL
|
|
static_assert(uavcan_file_Modify_Request_1_1_EXTENT_BYTES_ >= uavcan_file_Modify_Request_1_1_SERIALIZATION_BUFFER_SIZE_BYTES_,
|
|
"Internal constraint violation");
|
|
|
|
typedef struct
|
|
{
|
|
/// saturated bool preserve_source
|
|
bool preserve_source;
|
|
|
|
/// saturated bool overwrite_destination
|
|
bool overwrite_destination;
|
|
|
|
/// uavcan.file.Path.2.0 source
|
|
uavcan_file_Path_2_0 source;
|
|
|
|
/// uavcan.file.Path.2.0 destination
|
|
uavcan_file_Path_2_0 destination;
|
|
} uavcan_file_Modify_Request_1_1;
|
|
|
|
/// 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_file_Modify_Request_1_1_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_file_Modify_Request_1_1_serialize_(
|
|
const uavcan_file_Modify_Request_1_1* 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) < 4128UL)
|
|
{
|
|
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;
|
|
{ // saturated bool preserve_source
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits + 1ULL) <= (capacity_bytes * 8U));
|
|
buffer[offset_bits / 8U] = obj->preserve_source ? 1U : 0U;
|
|
offset_bits += 1U;
|
|
}
|
|
{ // saturated bool overwrite_destination
|
|
NUNAVUT_ASSERT((offset_bits + 1ULL) <= (capacity_bytes * 8U));
|
|
if (obj->overwrite_destination)
|
|
{
|
|
buffer[offset_bits / 8U] = (uint8_t)(buffer[offset_bits / 8U] | (1U << (offset_bits % 8U)));
|
|
}
|
|
else
|
|
{
|
|
buffer[offset_bits / 8U] = (uint8_t)(buffer[offset_bits / 8U] & ~(1U << (offset_bits % 8U)));
|
|
}
|
|
offset_bits += 1U;
|
|
}
|
|
{ // void30
|
|
NUNAVUT_ASSERT((offset_bits + 30ULL) <= (capacity_bytes * 8U));
|
|
const int8_t _err0_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, 30U); // Optimize?
|
|
if (_err0_ < 0)
|
|
{
|
|
return _err0_;
|
|
}
|
|
offset_bits += 30UL;
|
|
}
|
|
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.file.Path.2.0 source
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits + 2048ULL) <= (capacity_bytes * 8U));
|
|
size_t _size_bytes0_ = 256UL; // Nested object (max) size, in bytes.
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes0_) <= capacity_bytes);
|
|
int8_t _err2_ = uavcan_file_Path_2_0_serialize_(
|
|
&obj->source, &buffer[offset_bits / 8U], &_size_bytes0_);
|
|
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_bytes0_ * 8U) >= 8ULL);
|
|
NUNAVUT_ASSERT((_size_bytes0_ * 8U) <= 2048ULL);
|
|
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 _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.file.Path.2.0 destination
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits + 2048ULL) <= (capacity_bytes * 8U));
|
|
size_t _size_bytes1_ = 256UL; // Nested object (max) size, in bytes.
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes1_) <= capacity_bytes);
|
|
int8_t _err4_ = uavcan_file_Path_2_0_serialize_(
|
|
&obj->destination, &buffer[offset_bits / 8U], &_size_bytes1_);
|
|
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_bytes1_ * 8U) >= 8ULL);
|
|
NUNAVUT_ASSERT((_size_bytes1_ * 8U) <= 2048ULL);
|
|
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 _pad2_ = (uint8_t)(8U - offset_bits % 8U);
|
|
NUNAVUT_ASSERT(_pad2_ > 0);
|
|
const int8_t _err5_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, _pad2_); // Optimize?
|
|
if (_err5_ < 0)
|
|
{
|
|
return _err5_;
|
|
}
|
|
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 >= 48ULL);
|
|
NUNAVUT_ASSERT(offset_bits <= 4128ULL);
|
|
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_file_Modify_Request_1_1_deserialize_(
|
|
uavcan_file_Modify_Request_1_1* 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;
|
|
// saturated bool preserve_source
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
if (offset_bits < capacity_bits)
|
|
{
|
|
out_obj->preserve_source = (buffer[offset_bits / 8U] & 1U) != 0U;
|
|
}
|
|
else
|
|
{
|
|
out_obj->preserve_source = false;
|
|
}
|
|
offset_bits += 1U;
|
|
// saturated bool overwrite_destination
|
|
if (offset_bits < capacity_bits)
|
|
{
|
|
out_obj->overwrite_destination = (buffer[offset_bits / 8U] & (1U << (offset_bits % 8U))) != 0U;
|
|
}
|
|
else
|
|
{
|
|
out_obj->overwrite_destination = false;
|
|
}
|
|
offset_bits += 1U;
|
|
// void30
|
|
offset_bits += 30;
|
|
offset_bits = (offset_bits + 7U) & ~(size_t) 7U; // Align on 8 bits.
|
|
// uavcan.file.Path.2.0 source
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
{
|
|
size_t _size_bytes2_ = (size_t)(capacity_bytes - nunavutChooseMin((offset_bits / 8U), capacity_bytes));
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
const int8_t _err6_ = uavcan_file_Path_2_0_deserialize_(
|
|
&out_obj->source, &buffer[offset_bits / 8U], &_size_bytes2_);
|
|
if (_err6_ < 0)
|
|
{
|
|
return _err6_;
|
|
}
|
|
offset_bits += _size_bytes2_ * 8U; // Advance by the size of the nested serialized representation.
|
|
}
|
|
offset_bits = (offset_bits + 7U) & ~(size_t) 7U; // Align on 8 bits.
|
|
// uavcan.file.Path.2.0 destination
|
|
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 _err7_ = uavcan_file_Path_2_0_deserialize_(
|
|
&out_obj->destination, &buffer[offset_bits / 8U], &_size_bytes3_);
|
|
if (_err7_ < 0)
|
|
{
|
|
return _err7_;
|
|
}
|
|
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.
|
|
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_file_Modify_Request_1_1_initialize_(uavcan_file_Modify_Request_1_1* const out_obj)
|
|
{
|
|
if (out_obj != NULL)
|
|
{
|
|
size_t size_bytes = 0;
|
|
const uint8_t buf = 0;
|
|
const int8_t err = uavcan_file_Modify_Request_1_1_deserialize_(out_obj, &buf, &size_bytes);
|
|
NUNAVUT_ASSERT(err >= 0);
|
|
(void) err;
|
|
}
|
|
}
|
|
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
// | uavcan.file.Modify.Response.1.1
|
|
// +-------------------------------------------------------------------------------------------------------------------+
|
|
#define uavcan_file_Modify_Response_1_1_FULL_NAME_ "uavcan.file.Modify.Response"
|
|
#define uavcan_file_Modify_Response_1_1_FULL_NAME_AND_VERSION_ "uavcan.file.Modify.Response.1.1"
|
|
|
|
/// 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_file_Modify_Response_1_1_EXTENT_BYTES_ 48UL
|
|
#define uavcan_file_Modify_Response_1_1_SERIALIZATION_BUFFER_SIZE_BYTES_ 2UL
|
|
static_assert(uavcan_file_Modify_Response_1_1_EXTENT_BYTES_ >= uavcan_file_Modify_Response_1_1_SERIALIZATION_BUFFER_SIZE_BYTES_,
|
|
"Internal constraint violation");
|
|
|
|
typedef struct
|
|
{
|
|
/// uavcan.file.Error.1.0 error
|
|
uavcan_file_Error_1_0 _error;
|
|
} uavcan_file_Modify_Response_1_1;
|
|
|
|
/// 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_file_Modify_Response_1_1_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_file_Modify_Response_1_1_serialize_(
|
|
const uavcan_file_Modify_Response_1_1* 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) < 16UL)
|
|
{
|
|
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.file.Error.1.0 error
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits + 16ULL) <= (capacity_bytes * 8U));
|
|
size_t _size_bytes4_ = 2UL; // Nested object (max) size, in bytes.
|
|
NUNAVUT_ASSERT(offset_bits % 8U == 0U);
|
|
NUNAVUT_ASSERT((offset_bits / 8U + _size_bytes4_) <= capacity_bytes);
|
|
int8_t _err8_ = uavcan_file_Error_1_0_serialize_(
|
|
&obj->_error, &buffer[offset_bits / 8U], &_size_bytes4_);
|
|
if (_err8_ < 0)
|
|
{
|
|
return _err8_;
|
|
}
|
|
// It is assumed that we know the exact type of the serialized entity, hence we expect the size to match.
|
|
NUNAVUT_ASSERT((_size_bytes4_ * 8U) == 16ULL);
|
|
offset_bits += _size_bytes4_ * 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 _pad3_ = (uint8_t)(8U - offset_bits % 8U);
|
|
NUNAVUT_ASSERT(_pad3_ > 0);
|
|
const int8_t _err9_ = nunavutSetUxx(&buffer[0], capacity_bytes, offset_bits, 0U, _pad3_); // Optimize?
|
|
if (_err9_ < 0)
|
|
{
|
|
return _err9_;
|
|
}
|
|
offset_bits += _pad3_;
|
|
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 == 16ULL);
|
|
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_file_Modify_Response_1_1_deserialize_(
|
|
uavcan_file_Modify_Response_1_1* 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.file.Error.1.0 error
|
|
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_file_Error_1_0_deserialize_(
|
|
&out_obj->_error, &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.
|
|
}
|
|
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_file_Modify_Response_1_1_initialize_(uavcan_file_Modify_Response_1_1* const out_obj)
|
|
{
|
|
if (out_obj != NULL)
|
|
{
|
|
size_t size_bytes = 0;
|
|
const uint8_t buf = 0;
|
|
const int8_t err = uavcan_file_Modify_Response_1_1_deserialize_(out_obj, &buf, &size_bytes);
|
|
NUNAVUT_ASSERT(err >= 0);
|
|
(void) err;
|
|
}
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif // UAVCAN_FILE_MODIFY_1_1_INCLUDED_
|