NanoPB: Як обробляти повторювані поля (масиви) в C++

Див. також: C version: How to handle repeated fields/arrays in C

NanoPB — це оптимізована за розміром коду реалізація Protocol Buffers для вбудованих систем. Ця публікація показує, як обробляти повторювані поля (масиви) у C++ за допомогою NanoPB.

Визначення Proto

Спочатку створіть файл .proto з повторюваними полями:

repeated.proto

syntax = "proto3";

package example;

message RepeatedMessage {
  repeated uint32 values = 1;
  repeated float temperatures = 2;
}

syntax = "proto3";

package example;

message RepeatedMessage {
  repeated uint32 values = 1;
  repeated float temperatures = 2;
}

Генерація коду NanoPB

Згенеруйте код NanoPB за допомогою файлу .options, щоб задати розміри масивів:

Створіть repeated.options:

repeated.options

example.RepeatedMessage.values max_count:10

example.RepeatedMessage.values max_count:10

Потім згенеруйте:

generate_nanopb_repeated.sh

protoc --nanopb_out=. repeated.proto

protoc --nanopb_out=. repeated.proto

Це згенерує repeated.pb.h та repeated.pb.c.

Приклад на C++ з масивами фіксованого розміру

Ось повний приклад на C++ з використанням масивів фіксованого розміру:

repeated_example.cpp

#include <stdio.h>
#include "repeated.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Буфер для кодованого повідомлення
    uint8_t buffer[256];
    size_t message_length;
    
    // --- КОДУВАННЯ ---
    example_RepeatedMessage message = example_RepeatedMessage_init_zero;
    
    // Встановлення значень повторюваного поля
    message.values[0] = 10;
    message.values[1] = 20;
    message.values[2] = 30;
    message.values_count = 3;  // Важливо: встановіть count
    
    message.temperatures[0] = 20.5f;
    message.temperatures[1] = 21.0f;
    message.temperatures[2] = 21.5f;
    message.temperatures_count = 3;  // Важливо: встановіть count
    
    // Створення потоку для кодування
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Кодування повідомлення
    if (!pb_encode(&ostream, example_RepeatedMessage_fields, &message)) {
        printf("Помилка кодування: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Закодовано %zu байтів\n", message_length);
    
    // Вивід шістнадцяткового дампу закодованих даних
    printf("Закодовані дані: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- ДЕКОДУВАННЯ ---
    example_RepeatedMessage decoded = example_RepeatedMessage_init_zero;
    
    // Створення потоку для декодування
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Декодування повідомлення
    if (!pb_decode(&istream, example_RepeatedMessage_fields, &decoded)) {
        printf("Помилка декодування: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Вивід декодованих значень
    printf("Декодовані значення:\n");
    printf("  values (%zu елементів): ", decoded.values_count);
    for (size_t i = 0; i < decoded.values_count; i++) {
        printf("%u ", decoded.values[i]);
    }
    printf("\n");
    
    printf("  temperatures (%zu елементів): ", decoded.temperatures_count);
    for (size_t i = 0; i < decoded.temperatures_count; i++) {
        printf("%.1f ", decoded.temperatures[i]);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>
#include "repeated.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

int main() {
    // Буфер для кодованого повідомлення
    uint8_t buffer[256];
    size_t message_length;
    
    // --- КОДУВАННЯ ---
    example_RepeatedMessage message = example_RepeatedMessage_init_zero;
    
    // Встановлення значень повторюваного поля
    message.values[0] = 10;
    message.values[1] = 20;
    message.values[2] = 30;
    message.values_count = 3;  // Важливо: встановіть count
    
    message.temperatures[0] = 20.5f;
    message.temperatures[1] = 21.0f;
    message.temperatures[2] = 21.5f;
    message.temperatures_count = 3;  // Важливо: встановіть count
    
    // Створення потоку для кодування
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    // Кодування повідомлення
    if (!pb_encode(&ostream, example_RepeatedMessage_fields, &message)) {
        printf("Помилка кодування: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Закодовано %zu байтів\n", message_length);
    
    // Вивід шістнадцяткового дампу закодованих даних
    printf("Закодовані дані: ");
    for (size_t i = 0; i < message_length; i++) {
        printf("%02x ", buffer[i]);
    }
    printf("\n");
    
    // --- ДЕКОДУВАННЯ ---
    example_RepeatedMessage decoded = example_RepeatedMessage_init_zero;
    
    // Створення потоку для декодування
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    // Декодування повідомлення
    if (!pb_decode(&istream, example_RepeatedMessage_fields, &decoded)) {
        printf("Помилка декодування: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    // Вивід декодованих значень
    printf("Декодовані значення:\n");
    printf("  values (%zu елементів): ", decoded.values_count);
    for (size_t i = 0; i < decoded.values_count; i++) {
        printf("%u ", decoded.values[i]);
    }
    printf("\n");
    
    printf("  temperatures (%zu елементів): ", decoded.temperatures_count);
    for (size_t i = 0; i < decoded.temperatures_count; i++) {
        printf("%.1f ", decoded.temperatures[i]);
    }
    printf("\n");
    
    return 0;
}

Команда компіляції

Скомпілюйте приклад з nanopb. NanoPB зазвичай використовується шляхом безпосереднього включення вихідних файлів у ваш проєкт:

compile_repeated_example.sh

g++ -o repeated_example repeated_example.cpp repeated.pb.c pb_common.c pb_encode.c pb_decode.c -I.

g++ -o repeated_example repeated_example.cpp repeated.pb.c pb_common.c pb_encode.c pb_decode.c -I.

Примітка: Вихідні файли NanoPB (pb_common.c, pb_encode.c, pb_decode.c) потрібно компілювати безпосередньо з вашим проєктом. Їх можна отримати з репозиторію NanoPB на GitHub.

Скрипт тестування на Python

Щоб перевірити кодування, ви можете використати бібліотеку protobuf для Python:

test_repeated.py

import repeated_pb2

# Читання бінарних даних
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Декодування
msg = repeated_pb2.RepeatedMessage()
msg.ParseFromString(data)

print("Декодовані значення Python:")
print(f"  values: {list(msg.values)}")
print(f"  temperatures: {list(msg.temperatures)}")

import repeated_pb2

# Читання бінарних даних
with open('encoded.bin', 'rb') as f:
    data = f.read()

# Декодування
msg = repeated_pb2.RepeatedMessage()
msg.ParseFromString(data)

print("Декодовані значення Python:")
print(f"  values: {list(msg.values)}")
print(f"  temperatures: {list(msg.temperatures)}")

Спочатку скомпілюйте визначення protobuf для Python:

compile_python_repeated.sh

protoc --python_out=. repeated.proto

protoc --python_out=. repeated.proto

Потім змініть приклад на C++, щоб зберегти закодовані дані у файл:

save_encoded_repeated.cpp

// Після кодування додайте це:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

// Після кодування додайте це:
FILE *f = fopen("encoded.bin", "wb");
fwrite(buffer, 1, message_length, f);
fclose(f);

Альтернатива: Повторювані поля на основі зворотних викликів

Для динамічної обробки масивів ви можете використовувати зворотні виклики. Створіть repeated_callback.options:

repeated_callback.options

# Використовувати зворотний виклик для динамічних масивів
msg.RepeatedMessage.values callback
msg.RepeatedMessage.temperatures callback

# Використовувати зворотний виклик для динамічних масивів
msg.RepeatedMessage.values callback
msg.RepeatedMessage.temperatures callback

Потім згенеруйте знову та використовуйте цей підхід:

repeated_callback_example.cpp

#include <stdio.h>
#include <vector>
#include "repeated.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Зворотний виклик кодувальника для масиву uint32
bool uint32_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<uint32_t>* arr = (const std::vector<uint32_t>*)*arg;
    
    for (uint32_t value : *arr) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        if (!pb_encode_varint(stream, value))
            return false;
    }
    
    return true;
}

// Зворотний виклик декодера для масиву uint32
bool uint32_array_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<uint32_t>* arr = (std::vector<uint32_t>*)*arg;
    
    uint64_t value;
    if (!pb_decode_varint(stream, &value))
        return false;
    
    arr->push_back((uint32_t)value);
    return true;
}

// Зворотний виклик кодувальника для масиву float
bool float_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<float>* arr = (const std::vector<float>*)*arg;
    
    for (float value : *arr) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        // Кодування float як 4 байтів
        union { float f; uint32_t u; } u;
        u.f = value;
        if (!pb_encode_varint(stream, u.u))
            return false;
    }
    
    return true;
}

// Зворотний виклик декодера для масиву float
bool float_array_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<float>* arr = (std::vector<float>*)*arg;
    
    uint64_t value;
    if (!pb_decode_varint(stream, &value))
        return false;
    
    union { float f; uint32_t u; } u;
    u.u = (uint32_t)value;
    arr->push_back(u.f);
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::vector<uint32_t> values = {10, 20, 30};
    std::vector<float> temperatures = {20.5f, 21.0f, 21.5f};
    
    // --- КОДУВАННЯ ---
    example_RepeatedMessage message = example_RepeatedMessage_init_zero;
    
    message.values.funcs.encode = uint32_array_encode_callback;
    message.values.arg = &values;
    
    message.temperatures.funcs.encode = float_array_encode_callback;
    message.temperatures.arg = &temperatures;
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_RepeatedMessage_fields, &message)) {
        printf("Помилка кодування: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Закодовано %zu байтів\n", message_length);
    
    // --- ДЕКОДУВАННЯ ---
    example_RepeatedMessage decoded = example_RepeatedMessage_init_zero;
    std::vector<uint32_t> decoded_values;
    std::vector<float> decoded_temperatures;
    
    decoded.values.funcs.decode = uint32_array_decode_callback;
    decoded.values.arg = &decoded_values;
    
    decoded.temperatures.funcs.decode = float_array_decode_callback;
    decoded.temperatures.arg = &decoded_temperatures;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_RepeatedMessage_fields, &decoded)) {
        printf("Помилка декодування: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Декодовані значення:\n");
    printf("  values (%zu елементів): ", decoded_values.size());
    for (uint32_t value : decoded_values) {
        printf("%u ", value);
    }
    printf("\n");
    
    printf("  temperatures (%zu елементів): ", decoded_temperatures.size());
    for (float temp : decoded_temperatures) {
        printf("%.1f ", temp);
    }
    printf("\n");
    
    return 0;
}

#include <stdio.h>
#include <vector>
#include "repeated.pb.h"
#include "pb_encode.h"
#include "pb_decode.h"

// Зворотний виклик кодувальника для масиву uint32
bool uint32_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<uint32_t>* arr = (const std::vector<uint32_t>*)*arg;
    
    for (uint32_t value : *arr) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        if (!pb_encode_varint(stream, value))
            return false;
    }
    
    return true;
}

// Зворотний виклик декодера для масиву uint32
bool uint32_array_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<uint32_t>* arr = (std::vector<uint32_t>*)*arg;
    
    uint64_t value;
    if (!pb_decode_varint(stream, &value))
        return false;
    
    arr->push_back((uint32_t)value);
    return true;
}

// Зворотний виклик кодувальника для масиву float
bool float_array_encode_callback(pb_ostream_t *stream, const pb_field_t *field, void * const *arg) {
    const std::vector<float>* arr = (const std::vector<float>*)*arg;
    
    for (float value : *arr) {
        if (!pb_encode_tag_for_field(stream, field))
            return false;
        
        // Кодування float як 4 байтів
        union { float f; uint32_t u; } u;
        u.f = value;
        if (!pb_encode_varint(stream, u.u))
            return false;
    }
    
    return true;
}

// Зворотний виклик декодера для масиву float
bool float_array_decode_callback(pb_istream_t *stream, const pb_field_t *field, void **arg) {
    std::vector<float>* arr = (std::vector<float>*)*arg;
    
    uint64_t value;
    if (!pb_decode_varint(stream, &value))
        return false;
    
    union { float f; uint32_t u; } u;
    u.u = (uint32_t)value;
    arr->push_back(u.f);
    return true;
}

int main() {
    uint8_t buffer[256];
    size_t message_length;
    
    std::vector<uint32_t> values = {10, 20, 30};
    std::vector<float> temperatures = {20.5f, 21.0f, 21.5f};
    
    // --- КОДУВАННЯ ---
    example_RepeatedMessage message = example_RepeatedMessage_init_zero;
    
    message.values.funcs.encode = uint32_array_encode_callback;
    message.values.arg = &values;
    
    message.temperatures.funcs.encode = float_array_encode_callback;
    message.temperatures.arg = &temperatures;
    
    pb_ostream_t ostream = pb_ostream_from_buffer(buffer, sizeof(buffer));
    
    if (!pb_encode(&ostream, example_RepeatedMessage_fields, &message)) {
        printf("Помилка кодування: %s\n", PB_GET_ERROR(&ostream));
        return 1;
    }
    
    message_length = ostream.bytes_written;
    printf("Закодовано %zu байтів\n", message_length);
    
    // --- ДЕКОДУВАННЯ ---
    example_RepeatedMessage decoded = example_RepeatedMessage_init_zero;
    std::vector<uint32_t> decoded_values;
    std::vector<float> decoded_temperatures;
    
    decoded.values.funcs.decode = uint32_array_decode_callback;
    decoded.values.arg = &decoded_values;
    
    decoded.temperatures.funcs.decode = float_array_decode_callback;
    decoded.temperatures.arg = &decoded_temperatures;
    
    pb_istream_t istream = pb_istream_from_buffer(buffer, message_length);
    
    if (!pb_decode(&istream, example_RepeatedMessage_fields, &decoded)) {
        printf("Помилка декодування: %s\n", PB_GET_ERROR(&istream));
        return 1;
    }
    
    printf("Декодовані значення:\n");
    printf("  values (%zu елементів): ", decoded_values.size());
    for (uint32_t value : decoded_values) {
        printf("%u ", value);
    }
    printf("\n");
    
    printf("  temperatures (%zu елементів): ", decoded_temperatures.size());
    for (float temp : decoded_temperatures) {
        printf("%.1f ", temp);
    }
    printf("\n");
    
    return 0;
}

Ключові моменти

Масиви фіксованого розміру: Використовуйте max_count у файлі .options для простого статичного розподілу
На основі зворотних викликів: Використовуйте callback у .options для динамічної обробки масивів
Фіксований розмір: Встановіть поле *_count, щоб задати кількість елементів
На основі зворотних викликів: Реалізуйте зворотні виклики кодування/декодування для динамічного розподілу
Масиви кодуються як повторювані теги полів зі значеннями
Використовуйте std::vector<T> у C++ для динамічної обробки масивів
Завжди перевіряйте кількість елементів масиву, щоб уникнути переповнення

Коли використовувати який підхід

Масиви фіксованого розміру: Коли ви знаєте максимальний розмір масиву і хочете простий код
На основі зворотних викликів: Коли розмір масиву змінний або вам потрібне динамічне розподілення пам’яті

Очікуваний вивід

repeated_expected_output.txt

Encoded 15 bytes
Encoded data: 08 0a 08 14 08 1e 15 00 00 a4 41 15 00 00 a8 41 15 00 00 ac 41 
Decoded values:
  values (3 items): 10 20 30 
  temperatures (3 items): 20.5 21.0 21.5 

Encoded 15 bytes
Encoded data: 08 0a 08 14 08 1e 15 00 00 a4 41 15 00 00 a8 41 15 00 00 ac 41 
Decoded values:
  values (3 items): 10 20 30 
  temperatures (3 items): 20.5 21.0 21.5