jeans/esphome
jeans/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-08-05 09:57:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixes

Browse Source
This commit is contained in:
J. Nick Koston 2025-07-10 05:12:49 -10:00
parent 6b0391a1f9
commit 79dbeef0c9
No known key found for this signature in database
5 changed files with 135 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
esphome/components/api/api_pb2_size.h
View File

@ -128,20 +128,21 @@ class ProtoSize {
* All add_*_field methods follow these common patterns: * All add_*_field methods follow these common patterns:
* *
* @param total_size Reference to the total message size to update * @param total_size Reference to the total message size to update
* @param field_id_size Pre-calculated size of the field ID in bytes * @param precalced_field_id_size Pre-calculated size of the field ID in bytes
* @param value The value to calculate size for (type varies) * @param value The value to calculate size for (type varies)
* @param force Whether to calculate size even if the value is default/zero/empty * @param force Whether to calculate size even if the value is default/zero/empty
* *
* Each method follows this implementation pattern: * Each method follows this implementation pattern:
* 1. Skip calculation if value is default (0, false, empty) and not forced * 1. Skip calculation if value is default (0, false, empty) and not forced
* 2. Calculate the size based on the field's encoding rules * 2. Calculate the size based on the field's encoding rules
* 3. Add the field_id_size + calculated value size to total_size * 3. Add the precalced_field_id_size + calculated value size to total_size
*/ */
/** /**
* @brief Calculates and adds the size of an int32 field to the total message size * @brief Calculates and adds the size of an int32 field to the total message size
*/ */
static inline void add_int32_field(uint32_t &total_size, uint32_t field_id_size, int32_t value, bool force = false) { static inline void add_int32_field(uint32_t &total_size, uint32_t precalced_field_id_size, int32_t value,
bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
return; // No need to update total_size return; // No need to update total_size
@ -150,17 +151,17 @@ class ProtoSize {
// Calculate and directly add to total_size // Calculate and directly add to total_size
if (value < 0) { if (value < 0) {
// Negative values are encoded as 10-byte varints in protobuf // Negative values are encoded as 10-byte varints in protobuf
total_size += field_id_size + 10; total_size += precalced_field_id_size + 10;
} else { } else {
// For non-negative values, use the standard varint size // For non-negative values, use the standard varint size
total_size += field_id_size + varint(static_cast<uint32_t>(value)); total_size += precalced_field_id_size + varint(static_cast<uint32_t>(value));
} }
} }
/** /**
* @brief Calculates and adds the size of a uint32 field to the total message size * @brief Calculates and adds the size of a uint32 field to the total message size
*/ */
static inline void add_uint32_field(uint32_t &total_size, uint32_t field_id_size, uint32_t value, static inline void add_uint32_field(uint32_t &total_size, uint32_t precalced_field_id_size, uint32_t value,
bool force = false) { bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
@ -168,20 +169,21 @@ class ProtoSize {
} }
// Calculate and directly add to total_size // Calculate and directly add to total_size
total_size += field_id_size + varint(value); total_size += precalced_field_id_size + varint(value);
} }
/** /**
* @brief Calculates and adds the size of a boolean field to the total message size * @brief Calculates and adds the size of a boolean field to the total message size
*/ */
static inline void add_bool_field(uint32_t &total_size, uint32_t field_id_size, bool value, bool force = false) { static inline void add_bool_field(uint32_t &total_size, uint32_t precalced_field_id_size, bool value,
bool force = false) {
// Skip calculation if value is false and not forced // Skip calculation if value is false and not forced
if (!value && !force) { if (!value && !force) {
return; // No need to update total_size return; // No need to update total_size
} }
// Boolean fields always use 1 byte when true // Boolean fields always use 1 byte when true
total_size += field_id_size + 1; total_size += precalced_field_id_size + 1;
} }
/** /**
@ -193,7 +195,7 @@ class ProtoSize {
* @param is_nonzero Whether the value is non-zero * @param is_nonzero Whether the value is non-zero
*/ */
template<uint32_t NumBytes> template<uint32_t NumBytes>
static inline void add_fixed_field(uint32_t &total_size, uint32_t field_id_size, bool is_nonzero, static inline void add_fixed_field(uint32_t &total_size, uint32_t precalced_field_id_size, bool is_nonzero,
bool force = false) { bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (!is_nonzero && !force) { if (!is_nonzero && !force) {
@ -201,7 +203,7 @@ class ProtoSize {
} }
// Fixed fields always take exactly NumBytes // Fixed fields always take exactly NumBytes
total_size += field_id_size + NumBytes; total_size += precalced_field_id_size + NumBytes;
} }
/** /**
@ -209,14 +211,15 @@ class ProtoSize {
* *
* Enum fields are encoded as uint32 varints. * Enum fields are encoded as uint32 varints.
*/ */
static inline void add_enum_field(uint32_t &total_size, uint32_t field_id_size, uint32_t value, bool force = false) { static inline void add_enum_field(uint32_t &total_size, uint32_t precalced_field_id_size, uint32_t value,
bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
return; // No need to update total_size return; // No need to update total_size
} }
// Enums are encoded as uint32 // Enums are encoded as uint32
total_size += field_id_size + varint(value); total_size += precalced_field_id_size + varint(value);
} }
/** /**
@ -224,7 +227,8 @@ class ProtoSize {
* *
* Sint32 fields use ZigZag encoding, which is more efficient for negative values. * Sint32 fields use ZigZag encoding, which is more efficient for negative values.
*/ */
static inline void add_sint32_field(uint32_t &total_size, uint32_t field_id_size, int32_t value, bool force = false) { static inline void add_sint32_field(uint32_t &total_size, uint32_t precalced_field_id_size, int32_t value,
bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
return; // No need to update total_size return; // No need to update total_size
@ -232,26 +236,27 @@ class ProtoSize {
// ZigZag encoding for sint32: (n << 1) ^ (n >> 31) // ZigZag encoding for sint32: (n << 1) ^ (n >> 31)
uint32_t zigzag = (static_cast<uint32_t>(value) << 1) ^ (static_cast<uint32_t>(value >> 31)); uint32_t zigzag = (static_cast<uint32_t>(value) << 1) ^ (static_cast<uint32_t>(value >> 31));
total_size += field_id_size + varint(zigzag); total_size += precalced_field_id_size + varint(zigzag);
} }
/** /**
* @brief Calculates and adds the size of an int64 field to the total message size * @brief Calculates and adds the size of an int64 field to the total message size
*/ */
static inline void add_int64_field(uint32_t &total_size, uint32_t field_id_size, int64_t value, bool force = false) { static inline void add_int64_field(uint32_t &total_size, uint32_t precalced_field_id_size, int64_t value,
bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
return; // No need to update total_size return; // No need to update total_size
} }
// Calculate and directly add to total_size // Calculate and directly add to total_size
total_size += field_id_size + varint(value); total_size += precalced_field_id_size + varint(value);
} }
/** /**
* @brief Calculates and adds the size of a uint64 field to the total message size * @brief Calculates and adds the size of a uint64 field to the total message size
*/ */
static inline void add_uint64_field(uint32_t &total_size, uint32_t field_id_size, uint64_t value, static inline void add_uint64_field(uint32_t &total_size, uint32_t precalced_field_id_size, uint64_t value,
bool force = false) { bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
@ -259,7 +264,7 @@ class ProtoSize {
} }
// Calculate and directly add to total_size // Calculate and directly add to total_size
total_size += field_id_size + varint(value); total_size += precalced_field_id_size + varint(value);
} }
/** /**
@ -267,7 +272,8 @@ class ProtoSize {
* *
* Sint64 fields use ZigZag encoding, which is more efficient for negative values. * Sint64 fields use ZigZag encoding, which is more efficient for negative values.
*/ */
static inline void add_sint64_field(uint32_t &total_size, uint32_t field_id_size, int64_t value, bool force = false) { static inline void add_sint64_field(uint32_t &total_size, uint32_t precalced_field_id_size, int64_t value,
bool force = false) {
// Skip calculation if value is zero and not forced // Skip calculation if value is zero and not forced
if (value == 0 && !force) { if (value == 0 && !force) {
return; // No need to update total_size return; // No need to update total_size
@ -275,13 +281,13 @@ class ProtoSize {
// ZigZag encoding for sint64: (n << 1) ^ (n >> 63) // ZigZag encoding for sint64: (n << 1) ^ (n >> 63)
uint64_t zigzag = (static_cast<uint64_t>(value) << 1) ^ (static_cast<uint64_t>(value >> 63)); uint64_t zigzag = (static_cast<uint64_t>(value) << 1) ^ (static_cast<uint64_t>(value >> 63));
total_size += field_id_size + varint(zigzag); total_size += precalced_field_id_size + varint(zigzag);
} }
/** /**
* @brief Calculates and adds the size of a string/bytes field to the total message size * @brief Calculates and adds the size of a string/bytes field to the total message size
*/ */
static inline void add_string_field(uint32_t &total_size, uint32_t field_id_size, const std::string &str, static inline void add_string_field(uint32_t &total_size, uint32_t precalced_field_id_size, const std::string &str,
bool force = false) { bool force = false) {
// Skip calculation if string is empty and not forced // Skip calculation if string is empty and not forced
if (str.empty() && !force) { if (str.empty() && !force) {
@ -290,7 +296,7 @@ class ProtoSize {
// Calculate and directly add to total_size // Calculate and directly add to total_size
const uint32_t str_size = static_cast<uint32_t>(str.size()); const uint32_t str_size = static_cast<uint32_t>(str.size());
total_size += field_id_size + varint(str_size) + str_size; total_size += precalced_field_id_size + varint(str_size) + str_size;
} }
/** /**
@ -301,7 +307,7 @@ class ProtoSize {
* *
* @param nested_size The pre-calculated size of the nested message * @param nested_size The pre-calculated size of the nested message
*/ */
static inline void add_message_field(uint32_t &total_size, uint32_t field_id_size, uint32_t nested_size, static inline void add_message_field(uint32_t &total_size, uint32_t precalced_field_id_size, uint32_t nested_size,
bool force = false) { bool force = false) {
// Skip calculation if nested message is empty and not forced // Skip calculation if nested message is empty and not forced
if (nested_size == 0 && !force) { if (nested_size == 0 && !force) {
@ -310,7 +316,7 @@ class ProtoSize {
// Calculate and directly add to total_size // Calculate and directly add to total_size
// Field ID + length varint + nested message content // Field ID + length varint + nested message content
total_size += field_id_size + varint(nested_size) + nested_size; total_size += precalced_field_id_size + varint(nested_size) + nested_size;
} }
/** /**
@ -322,13 +328,13 @@ class ProtoSize {
* *
* @param message The nested message object * @param message The nested message object
*/ */
static inline void add_message_object(uint32_t &total_size, uint32_t field_id_size, const ProtoMessage &message, static inline void add_message_object(uint32_t &total_size, uint32_t precalced_field_id_size,
bool force = false) { const ProtoMessage &message, bool force = false) {
uint32_t nested_size = 0; uint32_t nested_size = 0;
message.calculate_size(nested_size); message.calculate_size(nested_size);
// Use the base implementation with the calculated nested_size // Use the base implementation with the calculated nested_size
add_message_field(total_size, field_id_size, nested_size, force); add_message_field(total_size, precalced_field_id_size, nested_size, force);
} }
/** /**
@ -341,7 +347,7 @@ class ProtoSize {
* @param messages Vector of message objects * @param messages Vector of message objects
*/ */
template<typename MessageType> template<typename MessageType>
static inline void add_repeated_message(uint32_t &total_size, uint32_t field_id_size, static inline void add_repeated_message(uint32_t &total_size, uint32_t precalced_field_id_size,
const std::vector<MessageType> &messages) { const std::vector<MessageType> &messages) {
// Skip if the vector is empty // Skip if the vector is empty
if (messages.empty()) { if (messages.empty()) {
@ -350,7 +356,7 @@ class ProtoSize {
// For repeated fields, always use force=true // For repeated fields, always use force=true
for (const auto &message : messages) { for (const auto &message : messages) {
add_message_object(total_size, field_id_size, message, true); add_message_object(total_size, precalced_field_id_size, message, true);
} }
} }
}; };

104
esphome/components/api/proto.cpp
View File

@ -162,69 +162,69 @@ void encode_bytes_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t
} }
// Type-specific size calculation functions // Type-specific size calculation functions
void size_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *str = static_cast<const std::string *>(field_ptr); const auto *str = static_cast<const std::string *>(field_ptr);
ProtoSize::add_string_field(total_size, precalced_field_tag_size, *str, force); ProtoSize::add_string_field(total_size, precalced_field_id_size, *str, force);
} }
void size_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const uint32_t *>(field_ptr); const auto *val = static_cast<const uint32_t *>(field_ptr);
ProtoSize::add_fixed_field<4>(total_size, precalced_field_tag_size, *val != 0 || force, force); ProtoSize::add_fixed_field<4>(total_size, precalced_field_id_size, *val != 0 || force, force);
} }
void size_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const bool *>(field_ptr); const auto *val = static_cast<const bool *>(field_ptr);
ProtoSize::add_bool_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_bool_field(total_size, precalced_field_id_size, *val, force);
} }
void size_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const float *>(field_ptr); const auto *val = static_cast<const float *>(field_ptr);
ProtoSize::add_fixed_field<4>(total_size, precalced_field_tag_size, *val != 0.0f || force, force); ProtoSize::add_fixed_field<4>(total_size, precalced_field_id_size, *val != 0.0f || force, force);
} }
void size_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const int32_t *>(field_ptr); const auto *val = static_cast<const int32_t *>(field_ptr);
ProtoSize::add_int32_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_int32_field(total_size, precalced_field_id_size, *val, force);
} }
void size_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const uint32_t *>(field_ptr); const auto *val = static_cast<const uint32_t *>(field_ptr);
ProtoSize::add_uint32_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_uint32_field(total_size, precalced_field_id_size, *val, force);
} }
void size_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const int64_t *>(field_ptr); const auto *val = static_cast<const int64_t *>(field_ptr);
ProtoSize::add_int64_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_int64_field(total_size, precalced_field_id_size, *val, force);
} }
void size_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const uint64_t *>(field_ptr); const auto *val = static_cast<const uint64_t *>(field_ptr);
ProtoSize::add_uint64_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_uint64_field(total_size, precalced_field_id_size, *val, force);
} }
void size_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const int32_t *>(field_ptr); const auto *val = static_cast<const int32_t *>(field_ptr);
ProtoSize::add_sint32_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_sint32_field(total_size, precalced_field_id_size, *val, force);
} }
void size_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const int64_t *>(field_ptr); const auto *val = static_cast<const int64_t *>(field_ptr);
ProtoSize::add_sint64_field(total_size, precalced_field_tag_size, *val, force); ProtoSize::add_sint64_field(total_size, precalced_field_id_size, *val, force);
} }
void size_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const uint64_t *>(field_ptr); const auto *val = static_cast<const uint64_t *>(field_ptr);
ProtoSize::add_fixed_field<8>(total_size, precalced_field_tag_size, *val != 0 || force, force); ProtoSize::add_fixed_field<8>(total_size, precalced_field_id_size, *val != 0 || force, force);
} }
void size_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const double *>(field_ptr); const auto *val = static_cast<const double *>(field_ptr);
ProtoSize::add_fixed_field<8>(total_size, precalced_field_tag_size, *val != 0.0 || force, force); ProtoSize::add_fixed_field<8>(total_size, precalced_field_id_size, *val != 0.0 || force, force);
} }
void size_bytes_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { void size_bytes_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *str = static_cast<const std::string *>(field_ptr); const auto *str = static_cast<const std::string *>(field_ptr);
ProtoSize::add_string_field(total_size, precalced_field_tag_size, *str, force); ProtoSize::add_string_field(total_size, precalced_field_id_size, *str, force);
} }
// Type-specific decode functions // Type-specific decode functions
@ -401,91 +401,91 @@ void encode_repeated_double_field(ProtoWriteBuffer &buffer, const void *field_pt
// Template repeated field functions moved to header // Template repeated field functions moved to header
// Repeated field size calculation functions // Repeated field size calculation functions
void size_repeated_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<std::string> *>(field_ptr); const auto *vec = static_cast<const std::vector<std::string> *>(field_ptr);
for (const auto &item : *vec) { for (const auto &item : *vec) {
ProtoSize::add_string_field(total_size, precalced_field_tag_size, item, true); ProtoSize::add_string_field(total_size, precalced_field_id_size, item, true);
} }
} }
void size_repeated_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<bool> *>(field_ptr); const auto *vec = static_cast<const std::vector<bool> *>(field_ptr);
for (bool val : *vec) { for (bool val : *vec) {
ProtoSize::add_bool_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_bool_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<uint32_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<uint32_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_uint32_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_uint32_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<int32_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<int32_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_int32_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_int32_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<uint64_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<uint64_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_uint64_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_uint64_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<int64_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<int64_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_int64_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_int64_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<int32_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<int32_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_sint32_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_sint32_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<int64_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<int64_t> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_sint64_field(total_size, precalced_field_tag_size, val, true); ProtoSize::add_sint64_field(total_size, precalced_field_id_size, val, true);
} }
} }
void size_repeated_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<uint32_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<uint32_t> *>(field_ptr);
size_t count = vec->size(); size_t count = vec->size();
if (count > 0) { if (count > 0) {
total_size += count * (precalced_field_tag_size + 4); // field tag + 4 bytes per item total_size += count * (precalced_field_id_size + 4); // field tag + 4 bytes per item
} }
} }
void size_repeated_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<uint64_t> *>(field_ptr); const auto *vec = static_cast<const std::vector<uint64_t> *>(field_ptr);
size_t count = vec->size(); size_t count = vec->size();
if (count > 0) { if (count > 0) {
total_size += count * (precalced_field_tag_size + 8); // field tag + 8 bytes per item total_size += count * (precalced_field_id_size + 8); // field tag + 8 bytes per item
} }
} }
void size_repeated_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<float> *>(field_ptr); const auto *vec = static_cast<const std::vector<float> *>(field_ptr);
size_t count = vec->size(); size_t count = vec->size();
if (count > 0) { if (count > 0) {
total_size += count * (precalced_field_tag_size + 4); // field tag + 4 bytes per item total_size += count * (precalced_field_id_size + 4); // field tag + 4 bytes per item
} }
} }
void size_repeated_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { void size_repeated_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<double> *>(field_ptr); const auto *vec = static_cast<const std::vector<double> *>(field_ptr);
size_t count = vec->size(); size_t count = vec->size();
if (count > 0) { if (count > 0) {
total_size += count * (precalced_field_tag_size + 8); // field tag + 8 bytes per item total_size += count * (precalced_field_id_size + 8); // field tag + 8 bytes per item
} }
} }
@ -516,13 +516,13 @@ void calculate_size_from_metadata(uint32_t &total_size, const void *obj, const F
// Calculate size for regular fields // Calculate size for regular fields
for (size_t i = 0; i < field_count; i++) { for (size_t i = 0; i < field_count; i++) {
const void *field_addr = base + fields[i].offset; const void *field_addr = base + fields[i].offset;
fields[i].sizer(total_size, field_addr, fields[i].precalced_field_tag_size, fields[i].force_encode); fields[i].sizer(total_size, field_addr, fields[i].precalced_field_id_size, fields[i].force_encode);
} }
// Calculate size for repeated fields // Calculate size for repeated fields
for (size_t i = 0; i < repeated_count; i++) { for (size_t i = 0; i < repeated_count; i++) {
const void *field_addr = base + repeated_fields[i].offset; const void *field_addr = base + repeated_fields[i].offset;
repeated_fields[i].sizer(total_size, field_addr, repeated_fields[i].precalced_field_tag_size); repeated_fields[i].sizer(total_size, field_addr, repeated_fields[i].precalced_field_id_size);
} }
} }

80
esphome/components/api/proto.h
View File

@ -18,7 +18,7 @@ class ProtoWriteBuffer;
// Function pointer types for encoding and size calculation // Function pointer types for encoding and size calculation
using EncodeFunc = void (*)(ProtoWriteBuffer &, const void *field_ptr, uint8_t field_num); using EncodeFunc = void (*)(ProtoWriteBuffer &, const void *field_ptr, uint8_t field_num);
using SizeFunc = void (*)(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); using SizeFunc = void (*)(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
// Macro to calculate field offset without triggering -Winvalid-offsetof // Macro to calculate field offset without triggering -Winvalid-offsetof
// This uses the same approach as offsetof but with explicit reinterpret_cast // This uses the same approach as offsetof but with explicit reinterpret_cast
@ -27,15 +27,15 @@ using SizeFunc = void (*)(uint32_t &total_size, const void *field_ptr, uint8_t p
// Function pointer types for repeated fields // Function pointer types for repeated fields
using RepeatedEncodeFunc = void (*)(ProtoWriteBuffer &, const void *field_ptr, uint8_t field_num); using RepeatedEncodeFunc = void (*)(ProtoWriteBuffer &, const void *field_ptr, uint8_t field_num);
using RepeatedSizeFunc = void (*)(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); using RepeatedSizeFunc = void (*)(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
// Special metadata for repeated fields // Special metadata for repeated fields
struct RepeatedFieldMeta { struct RepeatedFieldMeta {
uint8_t field_num; uint8_t field_num;
uint16_t offset; uint16_t offset;
RepeatedEncodeFunc encoder; // Encoder for the entire vector RepeatedEncodeFunc encoder; // Encoder for the entire vector
RepeatedSizeFunc sizer; // Sizer for the entire vector RepeatedSizeFunc sizer; // Sizer for the entire vector
uint8_t precalced_field_tag_size; // Pre-calculated size of field tag in bytes uint8_t precalced_field_id_size; // Pre-calculated size of field tag in bytes
}; };
/// Representation of a VarInt - in ProtoBuf should be 64bit but we only use 32bit /// Representation of a VarInt - in ProtoBuf should be 64bit but we only use 32bit
@ -217,13 +217,13 @@ using Decode64BitFunc = bool (*)(void *field_ptr, Proto64Bit value);
// Metadata structure describing each field // Metadata structure describing each field
struct FieldMeta { struct FieldMeta {
uint8_t field_num; // Protobuf field number (1-255) uint8_t field_num; // Protobuf field number (1-255)
uint16_t offset; // offset of field in class uint16_t offset; // offset of field in class
EncodeFunc encoder; // Function to encode this field type EncodeFunc encoder; // Function to encode this field type
SizeFunc sizer; // Function to calculate size for this field type SizeFunc sizer; // Function to calculate size for this field type
bool force_encode; // If true, encode even if value is default/empty bool force_encode; // If true, encode even if value is default/empty
uint8_t wire_type; // Wire type (0=varint, 2=length, 5=32bit, 1=64bit) uint8_t wire_type; // Wire type (0=varint, 2=length, 5=32bit, 1=64bit)
uint8_t precalced_field_tag_size; // Pre-calculated size of field tag in bytes uint8_t precalced_field_id_size; // Pre-calculated size of field tag in bytes
union { union {
DecodeVarintFunc decode_varint; DecodeVarintFunc decode_varint;
DecodeLengthFunc decode_length; DecodeLengthFunc decode_length;
@ -512,25 +512,25 @@ bool decode_bytes_field(void *field_ptr, ProtoLengthDelimited value);
template<typename EnumType> bool decode_enum_field(void *field_ptr, ProtoVarInt value); template<typename EnumType> bool decode_enum_field(void *field_ptr, ProtoVarInt value);
// Type-specific size calculation functions // Type-specific size calculation functions
void size_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
void size_bytes_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_bytes_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
// Template enum field functions // Template enum field functions
template<typename EnumType> void encode_enum_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num); template<typename EnumType> void encode_enum_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num);
template<typename EnumType> template<typename EnumType>
void size_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force); void size_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force);
// Repeated field handling functions // Repeated field handling functions
void encode_repeated_string_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num); void encode_repeated_string_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num);
@ -553,24 +553,24 @@ template<typename MessageType>
void encode_repeated_message_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num); void encode_repeated_message_field(ProtoWriteBuffer &buffer, const void *field_ptr, uint8_t field_num);
// Size calculation for repeated fields // Size calculation for repeated fields
void size_repeated_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_string_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_bool_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_uint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_int32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_uint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_int64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_sint32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_sint64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_fixed32_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_fixed64_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_float_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
void size_repeated_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_double_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
template<typename EnumType> template<typename EnumType>
void size_repeated_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
template<typename MessageType> template<typename MessageType>
void size_repeated_message_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size); void size_repeated_message_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size);
// Core shared functions // Core shared functions
void encode_from_metadata(ProtoWriteBuffer buffer, const void *obj, const FieldMeta *fields, size_t field_count, void encode_from_metadata(ProtoWriteBuffer buffer, const void *obj, const FieldMeta *fields, size_t field_count,

12
esphome/components/api/proto_templates.h
View File

@ -14,9 +14,9 @@ inline void encode_enum_field(ProtoWriteBuffer &buffer, const void *field_ptr, u
} }
template<typename EnumType> template<typename EnumType>
inline void size_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size, bool force) { inline void size_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size, bool force) {
const auto *val = static_cast<const EnumType *>(field_ptr); const auto *val = static_cast<const EnumType *>(field_ptr);
ProtoSize::add_enum_field(total_size, precalced_field_tag_size, static_cast<uint32_t>(*val), force); ProtoSize::add_enum_field(total_size, precalced_field_id_size, static_cast<uint32_t>(*val), force);
} }
template<typename EnumType> inline bool decode_enum_field(void *field_ptr, ProtoVarInt value) { template<typename EnumType> inline bool decode_enum_field(void *field_ptr, ProtoVarInt value) {
@ -44,17 +44,17 @@ inline void encode_repeated_message_field(ProtoWriteBuffer &buffer, const void *
// Template size functions for repeated fields (must be in header for instantiation) // Template size functions for repeated fields (must be in header for instantiation)
template<typename EnumType> template<typename EnumType>
inline void size_repeated_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { inline void size_repeated_enum_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<EnumType> *>(field_ptr); const auto *vec = static_cast<const std::vector<EnumType> *>(field_ptr);
for (const auto &val : *vec) { for (const auto &val : *vec) {
ProtoSize::add_enum_field(total_size, precalced_field_tag_size, static_cast<uint32_t>(val), true); ProtoSize::add_enum_field(total_size, precalced_field_id_size, static_cast<uint32_t>(val), true);
} }
} }
template<typename MessageType> template<typename MessageType>
inline void size_repeated_message_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_tag_size) { inline void size_repeated_message_field(uint32_t &total_size, const void *field_ptr, uint8_t precalced_field_id_size) {
const auto *vec = static_cast<const std::vector<MessageType> *>(field_ptr); const auto *vec = static_cast<const std::vector<MessageType> *>(field_ptr);
ProtoSize::add_repeated_message<MessageType>(total_size, precalced_field_tag_size, *vec); ProtoSize::add_repeated_message<MessageType>(total_size, precalced_field_id_size, *vec);
} }
} // namespace api } // namespace api

2
script/api_protobuf/api_protobuf.py
View File

@ -1242,7 +1242,7 @@ def build_message_type(
if encoder and sizer and decoder: if encoder and sizer and decoder:
# Calculate pre-calculated field tag size # Calculate pre-calculated field tag size
field_tag_size = ti.calculate_field_id_size() field_tag_size = ti.calculate_field_id_size()
# Format: {field_num, offset, encoder, sizer, force_encode, wire_type, precalced_field_tag_size, {decoder}} # Format: {field_num, offset, encoder, sizer, force_encode, wire_type, precalced_field_id_size, {decoder}}
decoder_field = ( decoder_field = (
f".decode_varint = {decoder}" f".decode_varint = {decoder}"
if wire_type == 0 if wire_type == 0