Assertion message

[detasse]

I am using FlatCC (version 0.6.2) to serialize a batch of FlatBuffers tables in C. My schema defines a root table DataPacketBatch which contains a vector of DataPacket tables. When I try to build a batch (array) of tables, my code follows the FlatCC documentation: I create all the DataPacket tables, collect their offsets, then create the vector of tables before starting the root table. Then, inside the root table block, I add the vector and finish the root as shown in the FlatCC manual.

However, when I run my program, it crashes with the following assertion failure
flatcc_builder_table_add_offset: Assertion `(B->frame[0].type) == flatcc_builder_table' failed.

Here is the code schema

namespace Data;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
   table DataPacket {                                                                                                                                                                                                                                                                
   timestamp:ulong;                                                                                                                                                                                                                                                              
   label:ushort;                                                                                                                                                                                                                                                                 
   type:ushort;                                                                                                                                                                                                                                                                  
   x0:uint;                                                                                                                                                                                                                                                                      
   data:[ushort];                                                                                                                                                                                                                                                            }     
table DataPacketBatch {                                                                                                                                                                                                                                                           
    packets: [DataPacket];  // Tableau de DataPackets                                                                                                                                                                                                                             
    batch_id:uint = 1;       // Identifiant du batch      
}
root_type DataPacketBatch;

Here is the C file

#include "data_packet_builder.h"
#include <stdio.h>
#include <stdlib.h>

#define BATCH_SIZE 2
#define DATA_COUNT 2

void create_and_save_batch() {
    flatcc_builder_t builder;
    flatcc_builder_init(&builder);

    Data_DataPacket_ref_t packet_offsets[BATCH_SIZE];
    uint16_t data[DATA_COUNT];

    for (size_t i = 0; i < BATCH_SIZE; i++) {
        for (size_t j = 0; j < DATA_COUNT; j++)
            data[j] = (uint16_t)(j + i);
        flatbuffers_uint16_vec_ref_t data_ref = flatbuffers_uint16_vec_create(&builder, data, DATA_COUNT);

        packet_offsets[i] = Data_DataPacket_create(
            &builder,
            1234567890123456789ULL + i,
            (uint16_t)(0xABCD + i),
            (uint16_t)(0x1234 + i),
            42 + i,
            data_ref
        );
    }
    flatbuffers_uoffset_t packets_vec = Data_DataPacketBatch_packets_create(&builder, packet_offsets, BATCH_SIZE);

    Data_DataPacketBatch_start(&builder);
    Data_DataPacketBatch_packets_add(&builder, packets_vec);
    Data_DataPacketBatch_end_as_root(&builder);

    size_t size;
    void *buffer = flatcc_builder_finalize_buffer(&builder, &size);
    FILE *fp = fopen("packet_batch.bin", "wb");
    fwrite(buffer, 1, size, fp);
    fclose(fp);

    flatcc_builder_clear(&builder);
}

int main() {
    create_and_save_batch();
    return 0;
}

[mikkelfj]

I'm not 100% sure (I don't recall the exact syntax), but the problem is likely:

A vector can be created as its own type, like in C++ and other languages, and then added as a field. Or it can be created inline and automatically be added. I think you are trying to do both.

The assertion is because the builder remembers the nesting levels, and each operation excepts something to be open, and you use an operation with the wrong thing (frame type).

Consider:
Data_DataPacketBatch_packets_create

This uses the syntax <namespace>_<table>_<field>_<verb>

So you want to call it after you have started the batch table and not store a temporary.
You can also create the vector as a type and then add it. Then it does not depend on a specific table being open.

I can dig into this some more if this is not enough.

Minor nits:

1. uoffset_t is a hack, you should find the proper _vec_ref_t type if you store a reference, but it doesn't really matter unless flatcc is used with different underlying type sizes.

2. In principle a vector cannot be created before a buffer is started. Usually like you do, both a buffer and a table is started at the same time. In this case you should create a vector after the start call. In praxis is seems to work before a buffer is opened (but only when you use the call to create the type and not the combined call that also adds it to table). However, if you do the same with nested buffers it will fail because then you store the vector outside of the nested buffer.

[detasse]

Thank you for your answer.
In principle a vector cannot be created before a buffer is started and this is what I changed in my code
Before

flatbuffers_uoffset_t packets_vec = Data_DataPacketBatch_packets_create(&builder, packet_offsets, BATCH_SIZE);

Data_DataPacketBatch_start(&builder);
Data_DataPacketBatch_packets_add(&builder, packets_vec);
Data_DataPacketBatch_end_as_root(&builder

New version

Data_DataPacket_start_as_root       (&builder); 
flatbuffers_uoffset_t packets_vec = Data_DataPacketBatch_packets_create(&builder, packet_offsets, BATCH_SIZE);
Data_DataPacket_end       (&builder); 
Data_DataPacketBatch_start(&builder);
Data_DataPacketBatch_packets_add(&builder, packets_vec);
Data_DataPacketBatch_end_as_root(&builder);

It works now.
Thank you again