Prepare files for public release

src/flatbuffers/AngleControlMessageBuilder.cpp

@@ -0,0 +1,22 @@
+//
+// Created by Johnathon Slightham on 2025-06-30.
+//
+
+#include "flatbuffers/AngleControlMessageBuilder.h"
+
+namespace Flatbuffers {
+const Messaging::AngleControlMessage *
+AngleControlMessageBuilder::parse_angle_control_message(const uint8_t *buffer) {
+    return flatbuffers::GetRoot<Messaging::AngleControlMessage>(buffer);
+}
+
+SerializedMessage AngleControlMessageBuilder::build_angle_control_message(const int16_t angle) {
+    builder_.Clear();
+
+    const auto message = Messaging::CreateAngleControlMessage(builder_, angle);
+
+    builder_.Finish(message);
+
+    return {builder_.GetBufferPointer(), builder_.GetSize()};
+}
+} // namespace Flatbuffers

src/flatbuffers/RobotConfigurationBuilder.cpp

@@ -0,0 +1,49 @@
+//
+// Created by Johnathon Slightham on 2025-07-25.
+//
+
+#include "flatbuffers/RobotConfigurationBuilder.h"
+
+#include "flatbuffers/SerializedMessage.h"
+#include "flatbuffers_generated/RobotConfiguration_generated.h"
+
+namespace Flatbuffers {
+
+SerializedMessage RobotConfigurationBuilder::build_robot_configuration(
+    const std::vector<ModuleInstance> &modules,
+    const std::vector<ModuleConnectionInstance> &connections) {
+    builder_.Clear();
+
+    std::vector<flatbuffers::Offset<RobotModule>> module_vector;
+    std::vector<flatbuffers::Offset<Frontend::ModuleConnection>> connection_vector;
+
+    for (const auto &connection : connections) {
+        connection_vector.push_back(Frontend::CreateModuleConnection(
+            builder_, connection.from_module_id, connection.to_module_id, connection.from_socket,
+            connection.to_socket, connection.orientation));
+    }
+
+    for (const auto &module : modules) {
+        // todo: this only works for motors right now
+        auto motor_state = CreateMotorState(builder_, module.angle);
+        const flatbuffers::Offset<void> config_union = motor_state.Union();
+        module_vector.push_back(CreateRobotModule(builder_, module.id, module.type,
+                                                  ModuleState_MotorState, config_union));
+    }
+
+    const auto connection_vector_fb = builder_.CreateVector(connection_vector);
+    const auto module_vector_fb = builder_.CreateVector(module_vector);
+
+    const auto message =
+        Frontend::CreateRobotConfiguration(builder_, module_vector_fb, connection_vector_fb);
+
+    builder_.Finish(message);
+
+    return {builder_.GetBufferPointer(), builder_.GetSize()};
+}
+
+const Frontend::RobotConfiguration *
+RobotConfigurationBuilder::parse_robot_configuration(const std::uint8_t *buffer) {
+    return flatbuffers::GetRoot<Frontend::RobotConfiguration>(buffer);
+}
+} // namespace Flatbuffers

src/flatbuffers/SensorMessageBuilder.cpp

@@ -0,0 +1,10 @@
+#include "flatbuffers/SensorMessageBuilder.h"
+#include "flatbuffers_generated/SensorMessage_generated.h"
+
+namespace Flatbuffers {
+
+const Messaging::SensorMessage *SensorMessageBuilder::parse_sensor_message(const uint8_t *buffer) {
+    return flatbuffers::GetRoot<Messaging::SensorMessage>(buffer);
+}
+
+} // namespace Flatbuffers

src/flatbuffers/TopologyMessageBuilder.cpp

@@ -0,0 +1,38 @@
+//
+// Created by Johnathon Slightham on 2025-06-30.
+//
+
+#include "flatbuffers/TopologyMessageBuilder.h"
+
+#include "flatbuffers/SerializedMessage.h"
+
+namespace Flatbuffers {
+SerializedMessage
+TopologyMessageBuilder::build_topology_message(const uint8_t module_id,
+                                               const ModuleType module_type,
+                                               const std::vector<uint8_t> &channel_to_module,
+                                               const std::vector<int8_t> &orientation_to_module) {
+    builder_.Clear();
+
+    const auto orientation_to_module_vector = builder_.CreateVector(orientation_to_module);
+    const auto channel_to_module_vector = builder_.CreateVector(channel_to_module);
+
+    const auto message =
+        Messaging::CreateTopologyMessage(builder_, module_id, module_type, channel_to_module.size(),
+                                         channel_to_module_vector, orientation_to_module_vector);
+
+    builder_.Finish(message);
+
+    return {builder_.GetBufferPointer(), builder_.GetSize()};
+}
+
+const Messaging::TopologyMessage *
+TopologyMessageBuilder::parse_topology_message(const uint8_t *buffer) {
+    return flatbuffers::GetRoot<Messaging::TopologyMessage>(buffer);
+}
+
+bool TopologyMessageBuilder::is_valid_topology_message(const uint8_t *buffer, size_t size) {
+    flatbuffers::Verifier verifier(buffer, size);
+    return Messaging::VerifyTopologyMessageBuffer(verifier);
+}
+} // namespace Flatbuffers