Appendix F FlatBuffers Table Laboratory

Book contents · Previous: Appendix E Mutable Semantic Laboratory · Next: Appendix G Sources and Edition Notes

Appendix F of FlatBuffers & FlexBuffers: From Bytes to Mutable Memory. FlatBuffers Table Laboratory from the complete supplied first edition.

This is the supplied first edition, pinned to its September 2026 source baseline. The laboratories and LiveFlex capstone are educational implementations and design proposals. The book overview explains the evidence limits; Reaktor’s performance review documents the current framework.

Appendix F: Complete FlatBuffers table laboratory

File: include/flat_table_lab.hpp. This deliberately small implementation constructs and reads the worked Sample table. It is not a schema compiler, general FlatBuffers builder, or complete FlatBuffers verifier.

Source file: include/flat_table_lab.hpp.

// A checked, schema-specific FlatBuffers table lesson, NOT a general compiler.
// SPDX-License-Identifier: MIT
#pragma once
#include "flex_wire.hpp"
namespace flexlab::flat {
// table Sample { count:int = 0; name:string; } root_type Sample;
inline Bytes sample(std::int32_t count, std::string_view name) {
 require(name.size()<=UINT32_MAX,"string too long");
 Bytes b;
 store_u(b,12,4);                 // root table at 12
 store_u(b,8,2); store_u(b,12,2); // vtable size, inline object size
 store_u(b,4,2); store_u(b,8,2);  // count and name positions in table
 store_u(b,8,4);                 // table 12 minus displacement 8 -> vtable 4
 store_u(b,std::bit_cast<std::uint32_t>(count),4);
 store_u(b,4,4);                 // name offset at 20 -> length at 24
 store_u(b,name.size(),4);
 b.insert(b.end(),name.begin(),name.end()); b.push_back(0);
 b.resize(align_up(b.size(),4),0); return b;
}
class Sample {
 ByteSpan b_;
 std::size_t table_, vt_;
 std::size_t field(unsigned index, unsigned width) const {
   const auto entry=4+2*index;
   const auto vt_size=load_u(b_,vt_,2);
   if (entry+2>vt_size) return 0;
   const auto off=load_u(b_,vt_+entry,2); if (!off) return 0;
   const auto object_size=load_u(b_,vt_+2,2);
   require(off>=4 && off<=object_size && width<=object_size-off,"field outside inline object");
   const auto p=add(table_,static_cast<std::size_t>(off)); range(b_,p,width); return p;
 }
public:
 explicit Sample(ByteSpan b) : b_(b), table_(0), vt_(0) {
   table_=static_cast<std::size_t>(load_u(b_,0,4)); range(b_,table_,4);
   const auto d=load_i(b_,table_,4);
   if (d>=0) { require(static_cast<std::uint64_t>(d)<=table_,"vtable underflow"); vt_=table_-static_cast<std::size_t>(d); }
   else vt_=add(table_,static_cast<std::size_t>(-d));
   const auto len=load_u(b_,vt_,2);
   require(len>=4 && len%2==0,"bad vtable size"); range(b_,vt_,static_cast<std::size_t>(len));
   const auto object=load_u(b_,vt_+2,2); require(object>=4,"bad inline object size");
   range(b_,table_,static_cast<std::size_t>(object));
 }
 std::int32_t count() const {
   const auto p=field(0,4); return p ? static_cast<std::int32_t>(load_i(b_,p,4)) : 0;
 }
 std::optional<std::string_view> name() const {
   const auto p=field(1,4); if (!p) return std::nullopt;
   const auto q=add(p,static_cast<std::size_t>(load_u(b_,p,4)));
   const auto n=static_cast<std::size_t>(load_u(b_,q,4));
   const auto text=add(q,4); range(b_,text,add(n,1));
   require(b_[text+n]==0,"missing FlatBuffers string terminator");
   return std::string_view(reinterpret_cast<const char*>(b_.data()+text),n);
 }
};
} // namespace flexlab::flat

REFERENCE & COMPLETE SOURCE

Book contents · Previous: Appendix E Mutable Semantic Laboratory · Next: Appendix G Sources and Edition Notes