diff --git a/SoarProto/Aegis/CommandMessage.proto b/SoarProto/Aegis/CommandMessage.proto index 17b4bd0..1e29f2f 100644 --- a/SoarProto/Aegis/CommandMessage.proto +++ b/SoarProto/Aegis/CommandMessage.proto @@ -101,8 +101,23 @@ message FcbCommand { RSC_TEST_MEV_ENABLE = 23; // Not used for Aegis RSC_TEST_MEV_DISABLE = 24; // Not used for Aegis + //CAMERA COMMANDS + RSC_CAMERA_SWITCH = 25; + + RSC_CAM1_ENABLE = 26; + RSC_CAM1_DISABLE = 27; + + RSC_CAM2_ENABLE = 28; + RSC_CAM2_DISABLE = 29; + + RSC_CAM3_ENABLE = 30; + RSC_CAM3_DISABLE = 31; + + RSC_AIR_BRAKES_ENABLE = 32; + RSC_AIR_BRAKES_DISABLE = 33; + //-- TECHNICAL -- - RSC_NONE = 25; // Invalid command, must be last + RSC_NONE = 34; // Invalid command, must be last // TODO NEW : ADD NEW COMMANDS FOR HEATER? OR AIRBRAKES AND STUFF. OR CREATE A NEW MESSAGE TYPE FOR NON-FLIGHT-SEQUENCE COMMANDS? } diff --git a/SoarProto/Aegis/_C++/CommandMessage.hpp b/SoarProto/Aegis/_C++/CommandMessage.hpp index ee29d8c..460c307 100644 --- a/SoarProto/Aegis/_C++/CommandMessage.hpp +++ b/SoarProto/Aegis/_C++/CommandMessage.hpp @@ -67,7 +67,16 @@ class FcbCommand final: public ::EmbeddedProto::MessageInterface RSC_TEST_MEV_OPEN = 22, RSC_TEST_MEV_ENABLE = 23, RSC_TEST_MEV_DISABLE = 24, - RSC_NONE = 25 + RSC_CAMERA_SWITCH = 25, + RSC_CAM1_ENABLE = 26, + RSC_CAM1_DISABLE = 27, + RSC_CAM2_ENABLE = 28, + RSC_CAM2_DISABLE = 29, + RSC_CAM3_ENABLE = 30, + RSC_CAM3_DISABLE = 31, + RSC_AIR_BRAKES_ENABLE = 32, + RSC_AIR_BRAKES_DISABLE = 33, + RSC_NONE = 34 }; enum class FieldNumber : uint32_t diff --git a/SoarProto/Aegis/_Python/CommandMessage_pb2.py b/SoarProto/Aegis/_Python/CommandMessage_pb2.py index daf5206..35394f1 100644 --- a/SoarProto/Aegis/_Python/CommandMessage_pb2.py +++ b/SoarProto/Aegis/_Python/CommandMessage_pb2.py @@ -15,7 +15,7 @@ import CoreProto_pb2 as CoreProto__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x14\x43ommandMessage.proto\x12\x05Proto\x1a\x0f\x43oreProto.proto\"\x9a\x02\n\x0e\x43ommandMessage\x12\x1b\n\x06source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x06target\x18\x02 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x13source_sequence_num\x18\x03 \x01(\r\x12(\n\x0b\x66\x63\x62_command\x18\x04 \x01(\x0b\x32\x11.Proto.FcbCommandH\x00\x12(\n\x0bpbb_command\x18\x05 \x01(\x0b\x32\x11.Proto.PbbCommandH\x00\x12(\n\x0b\x66sb_command\x18\x06 \x01(\x0b\x32\x11.Proto.FsbCommandH\x00\x12(\n\x0blrb_command\x18\x07 \x01(\x0b\x32\x11.Proto.LrbCommandH\x00\x42\t\n\x07message\"\xa2\x05\n\nFcbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FcbCommand.Command\"\xe2\x04\n\x07\x43ommand\x12\x15\n\x11RSC_FIRST_INVALID\x10\x00\x12\x14\n\x10RSC_ANY_TO_ABORT\x10\x01\x12\x11\n\rRSC_OPEN_VENT\x10\x02\x12\x12\n\x0eRSC_CLOSE_VENT\x10\x03\x12\x12\n\x0eRSC_OPEN_DRAIN\x10\x04\x12\x13\n\x0fRSC_CLOSE_DRAIN\x10\x05\x12\x11\n\rRSC_MEV_CLOSE\x10\x06\x12\x11\n\rRSC_GOTO_FILL\x10\x07\x12\x15\n\x11RSC_ARM_CONFIRM_1\x10\x08\x12\x15\n\x11RSC_ARM_CONFIRM_2\x10\t\x12\x10\n\x0cRSC_GOTO_ARM\x10\n\x12\x16\n\x12RSC_GOTO_PRELAUNCH\x10\x0b\x12\x15\n\x11RSC_GOTO_IGNITION\x10\x0c\x12\x1a\n\x16RSC_IGNITION_TO_LAUNCH\x10\r\x12\x16\n\x12RSC_LAUNCH_TO_BURN\x10\x0e\x12\x15\n\x11RSC_BURN_TO_COAST\x10\x0f\x12\x18\n\x14RSC_COAST_TO_BRAKING\x10\x10\x12\x18\n\x14RSC_COAST_TO_DESCENT\x10\x11\x12\x1a\n\x16RSC_BRAKING_TO_DESCENT\x10\x12\x12\x1c\n\x18RSC_DESCENT_TO_TOUCHDOWN\x10\x13\x12!\n\x1dRSC_MANUAL_IGNITION_CONFIRMED\x10\x14\x12\x11\n\rRSC_GOTO_TEST\x10\x15\x12\x15\n\x11RSC_TEST_MEV_OPEN\x10\x16\x12\x17\n\x13RSC_TEST_MEV_ENABLE\x10\x17\x12\x18\n\x14RSC_TEST_MEV_DISABLE\x10\x18\x12\x0c\n\x08RSC_NONE\x10\x19\"\xb2\x01\n\nPbbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.PbbCommand.Command\"s\n\x07\x43ommand\x12\x0c\n\x08PBB_NONE\x10\x00\x12\x10\n\x0cPBB_OPEN_MEV\x10\x01\x12\x11\n\rPBB_CLOSE_MEV\x10\x02\x12\x12\n\x0ePBB_OPEN_DRAIN\x10\x03\x12\x13\n\x0fPBB_CLOSE_DRAIN\x10\x04\x12\x0c\n\x08PBB_LAST\x10\x05\"\xb0\x01\n\nLrbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.LrbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"Z\n\x07\x43ommand\x12\x0c\n\x08LRB_NONE\x10\x00\x12\x16\n\x12LRB_TARE_LOAD_CELL\x10\x01\x12\x1b\n\x17LRB_CALIBRATE_LOAD_CELL\x10\x02\x12\x0c\n\x08LRB_LAST\x10\x03\"\x87\x06\n\nFsbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FsbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"\xb0\x05\n\x07\x43ommand\x12\x0c\n\x08\x46SB_NONE\x10\x00\x12\x10\n\x0c\x46SB_OPEN_AC1\x10\x03\x12\x11\n\rFSB_CLOSE_AC1\x10\x04\x12\x10\n\x0c\x46SB_OPEN_AC2\x10\x05\x12\x11\n\rFSB_CLOSE_AC2\x10\x06\x12\x11\n\rFSB_OPEN_PBV1\x10\x07\x12\x12\n\x0e\x46SB_CLOSE_PBV1\x10\x08\x12\x11\n\rFSB_OPEN_PBV2\x10\t\x12\x12\n\x0e\x46SB_CLOSE_PBV2\x10\n\x12\x11\n\rFSB_OPEN_PBV3\x10\x0b\x12\x12\n\x0e\x46SB_CLOSE_PBV3\x10\x0c\x12\x11\n\rFSB_OPEN_PBV4\x10\r\x12\x12\n\x0e\x46SB_CLOSE_PBV4\x10\x0e\x12\x11\n\rFSB_OPEN_SOL5\x10\x15\x12\x12\n\x0e\x46SB_CLOSE_SOL5\x10\x16\x12\x11\n\rFSB_OPEN_SOL6\x10\x17\x12\x12\n\x0e\x46SB_CLOSE_SOL6\x10\x18\x12\x11\n\rFSB_OPEN_SOL7\x10\x19\x12\x12\n\x0e\x46SB_CLOSE_SOL7\x10\x1a\x12\x12\n\x0e\x46SB_OPEN_SOL8A\x10\x1b\x12\x13\n\x0f\x46SB_CLOSE_SOL8A\x10\x1c\x12\x12\n\x0e\x46SB_OPEN_SOL8B\x10\x1d\x12\x13\n\x0f\x46SB_CLOSE_SOL8B\x10\x1e\x12\x1b\n\x17\x46SB_TARE_NOS1_LOAD_CELL\x10!\x12\x1b\n\x17\x46SB_TARE_NOS2_LOAD_CELL\x10\"\x12 \n\x1c\x46SB_CALIBRATE_NOS1_LOAD_CELL\x10#\x12 \n\x1c\x46SB_CALIBRATE_NOS2_LOAD_CELL\x10$\x12\x17\n\x13\x46SB_IGNITE_PAD_BOX1\x10\x1f\x12\x17\n\x13\x46SB_IGNITE_PAD_BOX2\x10 \x12\x15\n\x11\x46SB_KILL_PAD_BOX1\x10%\x12\x15\n\x11\x46SB_KILL_PAD_BOX2\x10&\x12\x0c\n\x08\x46SB_LAST\x10\'b\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x14\x43ommandMessage.proto\x12\x05Proto\x1a\x0f\x43oreProto.proto\"\x9a\x02\n\x0e\x43ommandMessage\x12\x1b\n\x06source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x06target\x18\x02 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x13source_sequence_num\x18\x03 \x01(\r\x12(\n\x0b\x66\x63\x62_command\x18\x04 \x01(\x0b\x32\x11.Proto.FcbCommandH\x00\x12(\n\x0bpbb_command\x18\x05 \x01(\x0b\x32\x11.Proto.PbbCommandH\x00\x12(\n\x0b\x66sb_command\x18\x06 \x01(\x0b\x32\x11.Proto.FsbCommandH\x00\x12(\n\x0blrb_command\x18\x07 \x01(\x0b\x32\x11.Proto.LrbCommandH\x00\x42\t\n\x07message\"\xf1\x06\n\nFcbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FcbCommand.Command\"\xb1\x06\n\x07\x43ommand\x12\x15\n\x11RSC_FIRST_INVALID\x10\x00\x12\x14\n\x10RSC_ANY_TO_ABORT\x10\x01\x12\x11\n\rRSC_OPEN_VENT\x10\x02\x12\x12\n\x0eRSC_CLOSE_VENT\x10\x03\x12\x12\n\x0eRSC_OPEN_DRAIN\x10\x04\x12\x13\n\x0fRSC_CLOSE_DRAIN\x10\x05\x12\x11\n\rRSC_MEV_CLOSE\x10\x06\x12\x11\n\rRSC_GOTO_FILL\x10\x07\x12\x15\n\x11RSC_ARM_CONFIRM_1\x10\x08\x12\x15\n\x11RSC_ARM_CONFIRM_2\x10\t\x12\x10\n\x0cRSC_GOTO_ARM\x10\n\x12\x16\n\x12RSC_GOTO_PRELAUNCH\x10\x0b\x12\x15\n\x11RSC_GOTO_IGNITION\x10\x0c\x12\x1a\n\x16RSC_IGNITION_TO_LAUNCH\x10\r\x12\x16\n\x12RSC_LAUNCH_TO_BURN\x10\x0e\x12\x15\n\x11RSC_BURN_TO_COAST\x10\x0f\x12\x18\n\x14RSC_COAST_TO_BRAKING\x10\x10\x12\x18\n\x14RSC_COAST_TO_DESCENT\x10\x11\x12\x1a\n\x16RSC_BRAKING_TO_DESCENT\x10\x12\x12\x1c\n\x18RSC_DESCENT_TO_TOUCHDOWN\x10\x13\x12!\n\x1dRSC_MANUAL_IGNITION_CONFIRMED\x10\x14\x12\x11\n\rRSC_GOTO_TEST\x10\x15\x12\x15\n\x11RSC_TEST_MEV_OPEN\x10\x16\x12\x17\n\x13RSC_TEST_MEV_ENABLE\x10\x17\x12\x18\n\x14RSC_TEST_MEV_DISABLE\x10\x18\x12\x15\n\x11RSC_CAMERA_SWITCH\x10\x19\x12\x13\n\x0fRSC_CAM1_ENABLE\x10\x1a\x12\x14\n\x10RSC_CAM1_DISABLE\x10\x1b\x12\x13\n\x0fRSC_CAM2_ENABLE\x10\x1c\x12\x14\n\x10RSC_CAM2_DISABLE\x10\x1d\x12\x13\n\x0fRSC_CAM3_ENABLE\x10\x1e\x12\x14\n\x10RSC_CAM3_DISABLE\x10\x1f\x12\x19\n\x15RSC_AIR_BRAKES_ENABLE\x10 \x12\x1a\n\x16RSC_AIR_BRAKES_DISABLE\x10!\x12\x0c\n\x08RSC_NONE\x10\"\"\xb2\x01\n\nPbbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.PbbCommand.Command\"s\n\x07\x43ommand\x12\x0c\n\x08PBB_NONE\x10\x00\x12\x10\n\x0cPBB_OPEN_MEV\x10\x01\x12\x11\n\rPBB_CLOSE_MEV\x10\x02\x12\x12\n\x0ePBB_OPEN_DRAIN\x10\x03\x12\x13\n\x0fPBB_CLOSE_DRAIN\x10\x04\x12\x0c\n\x08PBB_LAST\x10\x05\"\xb0\x01\n\nLrbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.LrbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"Z\n\x07\x43ommand\x12\x0c\n\x08LRB_NONE\x10\x00\x12\x16\n\x12LRB_TARE_LOAD_CELL\x10\x01\x12\x1b\n\x17LRB_CALIBRATE_LOAD_CELL\x10\x02\x12\x0c\n\x08LRB_LAST\x10\x03\"\x87\x06\n\nFsbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FsbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"\xb0\x05\n\x07\x43ommand\x12\x0c\n\x08\x46SB_NONE\x10\x00\x12\x10\n\x0c\x46SB_OPEN_AC1\x10\x03\x12\x11\n\rFSB_CLOSE_AC1\x10\x04\x12\x10\n\x0c\x46SB_OPEN_AC2\x10\x05\x12\x11\n\rFSB_CLOSE_AC2\x10\x06\x12\x11\n\rFSB_OPEN_PBV1\x10\x07\x12\x12\n\x0e\x46SB_CLOSE_PBV1\x10\x08\x12\x11\n\rFSB_OPEN_PBV2\x10\t\x12\x12\n\x0e\x46SB_CLOSE_PBV2\x10\n\x12\x11\n\rFSB_OPEN_PBV3\x10\x0b\x12\x12\n\x0e\x46SB_CLOSE_PBV3\x10\x0c\x12\x11\n\rFSB_OPEN_PBV4\x10\r\x12\x12\n\x0e\x46SB_CLOSE_PBV4\x10\x0e\x12\x11\n\rFSB_OPEN_SOL5\x10\x15\x12\x12\n\x0e\x46SB_CLOSE_SOL5\x10\x16\x12\x11\n\rFSB_OPEN_SOL6\x10\x17\x12\x12\n\x0e\x46SB_CLOSE_SOL6\x10\x18\x12\x11\n\rFSB_OPEN_SOL7\x10\x19\x12\x12\n\x0e\x46SB_CLOSE_SOL7\x10\x1a\x12\x12\n\x0e\x46SB_OPEN_SOL8A\x10\x1b\x12\x13\n\x0f\x46SB_CLOSE_SOL8A\x10\x1c\x12\x12\n\x0e\x46SB_OPEN_SOL8B\x10\x1d\x12\x13\n\x0f\x46SB_CLOSE_SOL8B\x10\x1e\x12\x1b\n\x17\x46SB_TARE_NOS1_LOAD_CELL\x10!\x12\x1b\n\x17\x46SB_TARE_NOS2_LOAD_CELL\x10\"\x12 \n\x1c\x46SB_CALIBRATE_NOS1_LOAD_CELL\x10#\x12 \n\x1c\x46SB_CALIBRATE_NOS2_LOAD_CELL\x10$\x12\x17\n\x13\x46SB_IGNITE_PAD_BOX1\x10\x1f\x12\x17\n\x13\x46SB_IGNITE_PAD_BOX2\x10 \x12\x15\n\x11\x46SB_KILL_PAD_BOX1\x10%\x12\x15\n\x11\x46SB_KILL_PAD_BOX2\x10&\x12\x0c\n\x08\x46SB_LAST\x10\'b\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -25,19 +25,19 @@ _globals['_COMMANDMESSAGE']._serialized_start=49 _globals['_COMMANDMESSAGE']._serialized_end=331 _globals['_FCBCOMMAND']._serialized_start=334 - _globals['_FCBCOMMAND']._serialized_end=1008 + _globals['_FCBCOMMAND']._serialized_end=1215 _globals['_FCBCOMMAND_COMMAND']._serialized_start=398 - _globals['_FCBCOMMAND_COMMAND']._serialized_end=1008 - _globals['_PBBCOMMAND']._serialized_start=1011 - _globals['_PBBCOMMAND']._serialized_end=1189 - _globals['_PBBCOMMAND_COMMAND']._serialized_start=1074 - _globals['_PBBCOMMAND_COMMAND']._serialized_end=1189 - _globals['_LRBCOMMAND']._serialized_start=1192 - _globals['_LRBCOMMAND']._serialized_end=1368 - _globals['_LRBCOMMAND_COMMAND']._serialized_start=1278 - _globals['_LRBCOMMAND_COMMAND']._serialized_end=1368 - _globals['_FSBCOMMAND']._serialized_start=1371 - _globals['_FSBCOMMAND']._serialized_end=2146 - _globals['_FSBCOMMAND_COMMAND']._serialized_start=1458 - _globals['_FSBCOMMAND_COMMAND']._serialized_end=2146 + _globals['_FCBCOMMAND_COMMAND']._serialized_end=1215 + _globals['_PBBCOMMAND']._serialized_start=1218 + _globals['_PBBCOMMAND']._serialized_end=1396 + _globals['_PBBCOMMAND_COMMAND']._serialized_start=1281 + _globals['_PBBCOMMAND_COMMAND']._serialized_end=1396 + _globals['_LRBCOMMAND']._serialized_start=1399 + _globals['_LRBCOMMAND']._serialized_end=1575 + _globals['_LRBCOMMAND_COMMAND']._serialized_start=1485 + _globals['_LRBCOMMAND_COMMAND']._serialized_end=1575 + _globals['_FSBCOMMAND']._serialized_start=1578 + _globals['_FSBCOMMAND']._serialized_end=2353 + _globals['_FSBCOMMAND_COMMAND']._serialized_start=1665 + _globals['_FSBCOMMAND_COMMAND']._serialized_end=2353 # @@protoc_insertion_point(module_scope) diff --git a/SoarProto/Aegis/_Python/CommandMessage_pb2.pyi b/SoarProto/Aegis/_Python/CommandMessage_pb2.pyi index e1fe97a..1f23735 100644 --- a/SoarProto/Aegis/_Python/CommandMessage_pb2.pyi +++ b/SoarProto/Aegis/_Python/CommandMessage_pb2.pyi @@ -53,6 +53,15 @@ class FcbCommand(_message.Message): RSC_TEST_MEV_OPEN: _ClassVar[FcbCommand.Command] RSC_TEST_MEV_ENABLE: _ClassVar[FcbCommand.Command] RSC_TEST_MEV_DISABLE: _ClassVar[FcbCommand.Command] + RSC_CAMERA_SWITCH: _ClassVar[FcbCommand.Command] + RSC_CAM1_ENABLE: _ClassVar[FcbCommand.Command] + RSC_CAM1_DISABLE: _ClassVar[FcbCommand.Command] + RSC_CAM2_ENABLE: _ClassVar[FcbCommand.Command] + RSC_CAM2_DISABLE: _ClassVar[FcbCommand.Command] + RSC_CAM3_ENABLE: _ClassVar[FcbCommand.Command] + RSC_CAM3_DISABLE: _ClassVar[FcbCommand.Command] + RSC_AIR_BRAKES_ENABLE: _ClassVar[FcbCommand.Command] + RSC_AIR_BRAKES_DISABLE: _ClassVar[FcbCommand.Command] RSC_NONE: _ClassVar[FcbCommand.Command] RSC_FIRST_INVALID: FcbCommand.Command RSC_ANY_TO_ABORT: FcbCommand.Command @@ -79,6 +88,15 @@ class FcbCommand(_message.Message): RSC_TEST_MEV_OPEN: FcbCommand.Command RSC_TEST_MEV_ENABLE: FcbCommand.Command RSC_TEST_MEV_DISABLE: FcbCommand.Command + RSC_CAMERA_SWITCH: FcbCommand.Command + RSC_CAM1_ENABLE: FcbCommand.Command + RSC_CAM1_DISABLE: FcbCommand.Command + RSC_CAM2_ENABLE: FcbCommand.Command + RSC_CAM2_DISABLE: FcbCommand.Command + RSC_CAM3_ENABLE: FcbCommand.Command + RSC_CAM3_DISABLE: FcbCommand.Command + RSC_AIR_BRAKES_ENABLE: FcbCommand.Command + RSC_AIR_BRAKES_DISABLE: FcbCommand.Command RSC_NONE: FcbCommand.Command COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] command_enum: FcbCommand.Command diff --git a/SoarProto/Ouroboros/CoreProto.proto b/SoarProto/Ouroboros/CoreProto.proto index bae8fcc..80954aa 100644 --- a/SoarProto/Ouroboros/CoreProto.proto +++ b/SoarProto/Ouroboros/CoreProto.proto @@ -16,10 +16,10 @@ enum Node { NODE_UNKNOWN = 1; // This can happen if the node is not yet known at this stage, eg. COBS decode failed NODE_ANY = 2; - NODE_RCU = 3; - NODE_DMB = 4; + NODE_FSB = 3; + NODE_FCB = 4; NODE_PBB = 5; - NODE_SOB = 6; + NODE_LRB = 6; } enum MessageID { diff --git a/SoarProto/ProtocolTask.cpp b/SoarProto/ProtocolTask.cpp index 0969637..52f1c3b 100644 --- a/SoarProto/ProtocolTask.cpp +++ b/SoarProto/ProtocolTask.cpp @@ -1,10 +1,10 @@ /** - ****************************************************************************** - * File Name : ProtocolTask.cpp - * Description : The base ProtocolTask for all boards, includes a UART Rx Handling and Functions for Tx/Rx of Protocol Data - * Should be derived from for a Board Specific Protocol Task that implements the pure virtual functions. - ****************************************************************************** -*/ + ****************************************************************************** + * File Name : ProtocolTask.cpp + * Description : The base ProtocolTask for all boards, includes a UART Rx Handling and Functions for Tx/Rx of Protocol Data + * Should be derived from for a Board Specific Protocol Task that implements the pure virtual functions. + ****************************************************************************** + */ /* Includes ------------------------------------------------------------------*/ #include "ProtocolTask.hpp" @@ -38,12 +38,12 @@ constexpr uint8_t PROTOCOL_TASK_PERIOD = 100; /** * @brief Constructor, sets all member variables */ -ProtocolTask::ProtocolTask(Proto::Node node, UARTDriver* uartDriver, uint16_t uartTaskCmd) : Task(TASK_PROTOCOL_QUEUE_DEPTH_OBJS), - kUart_(uartDriver), uartTaskCommand(uartTaskCmd), numUartErrors_(0) +ProtocolTask::ProtocolTask(Proto::Node node, UARTDriver *uartDriver, uint16_t uartTaskCmd) : Task(TASK_PROTOCOL_QUEUE_DEPTH_OBJS), + kUart_(uartDriver), uartTaskCommand(uartTaskCmd), numUartErrors_(0) { // Setup Buffers - protocolRxBuffer = soar_malloc(PROTOCOL_RX_BUFFER_SZ_BYTES+1); - memset(protocolRxBuffer, 0, PROTOCOL_RX_BUFFER_SZ_BYTES+1); + protocolRxBuffer = cube_malloc(PROTOCOL_RX_BUFFER_SZ_BYTES + 1); + memset(protocolRxBuffer, 0, PROTOCOL_RX_BUFFER_SZ_BYTES + 1); // Setup index and flags protocolMsgIdx = 0; @@ -54,55 +54,64 @@ ProtocolTask::ProtocolTask(Proto::Node node, UARTDriver* uartDriver, uint16_t ua /** * @brief Runcode for the ProtocolTask */ -void ProtocolTask::Run(void * pvParams) +void ProtocolTask::Run(void *pvParams) { // Arm the interrupt ReceiveData(); - while (1) { + while (1) + { Command cm; - //Wait forever for a command + // Wait forever for a command qEvtQueue->ReceiveWait(cm); - //If this is a PROTOCOL_COMMAND, process it - if (cm.GetCommand() == PROTOCOL_COMMAND) { - switch (cm.GetTaskCommand()) { - case EVENT_PROTOCOL_RX_COMPLETE: { //Process the command -- RX Complete - // If the message is of insufficient length, don't do anything - if(protocolMsgIdx < PROTOCOL_MINIMUM_MESSAGE_LENGTH) { + // If this is a PROTOCOL_COMMAND, process it + if (cm.GetCommand() == PROTOCOL_COMMAND) + { + switch (cm.GetTaskCommand()) + { + case EVENT_PROTOCOL_RX_COMPLETE: + { // Process the command -- RX Complete + // If the message is of insufficient length, don't do anything + if (protocolMsgIdx < PROTOCOL_MINIMUM_MESSAGE_LENGTH) + { // We can mark the rx buffer as safe to write to now protocolMsgIdx = 0; isProtocolMsgReady = false; - break; - } + break; + } // Allocate a command for storing the decoded message Command protoRx(PROTOCOL_COMMAND, PROTOCOL_RX_DECODED_DATA); - uint8_t* decodedDataPtr = protoRx.AllocateData(protocolMsgIdx-1); // We ignore the delimiter byte, so this is the worse case size + uint8_t *decodedDataPtr = protoRx.AllocateData(protocolMsgIdx - 1); // We ignore the delimiter byte, so this is the worse case size // Assert allocation was successful SOAR_ASSERT(decodedDataPtr); // When we get an Rx complete, we need to run the COBS decoder on the message - cobs_decode_result cobsRes = cobs_decode(decodedDataPtr, protocolMsgIdx, protocolRxBuffer, protocolMsgIdx-1); + cobs_decode_result cobsRes = cobs_decode(decodedDataPtr, protocolMsgIdx, protocolRxBuffer, protocolMsgIdx - 1); // We can mark the rx buffer as safe to write to now protocolMsgIdx = 0; isProtocolMsgReady = false; // If the COBS decode result is not OK, then we need to send a NACK - if (cobsRes.status != COBS_DECODE_OK) { - SOAR_PRINT("PROTO-INFO: COBS Decode Failed: %d %d\n", cobsRes.status, cobsRes.out_len); + if (cobsRes.status != COBS_DECODE_OK) + { + SOAR_PRINT("PROTO-INFO: COBS Decode Failed: %d %d\n", cobsRes.status, cobsRes.out_len); SendNACK(); } - else { + else + { // Verify the checksum is correct, send a NACK and don't process if incorrect - if (!Utils::IsCrc16Correct(decodedDataPtr, cobsRes.out_len - PROTOCOL_CHECKSUM_BYTES, *((uint16_t*)&decodedDataPtr[cobsRes.out_len - PROTOCOL_CHECKSUM_BYTES]))) { + if (!Utils::IsCrc16Correct(decodedDataPtr, cobsRes.out_len - PROTOCOL_CHECKSUM_BYTES, *((uint16_t *)&decodedDataPtr[cobsRes.out_len - PROTOCOL_CHECKSUM_BYTES]))) + { SOAR_PRINT("PROTO-INFO: Message Checksum Invalid!\n"); - SendNACK(); + SendNACK(); } - else { + else + { // Set the message size to the decoded buffer size, minus the checksum, since that should be validated protoRx.SetDataSize(cobsRes.out_len - PROTOCOL_CHECKSUM_BYTES); @@ -114,9 +123,10 @@ void ProtocolTask::Run(void * pvParams) protoRx.Reset(); break; } - case PROTOCOL_TX_REQUEST_DATA: { //Process the command -- TX Request + case PROTOCOL_TX_REQUEST_DATA: + { // Process the command -- TX Request - SOAR_PRINT("PROTO-INFO-Vs: TX Request Received [%d]\n", cm.GetDataSize()); + SOAR_PRINT("PROTO-INFO-Vs: TX Request Received [%d]\n", cm.GetDataSize()); // Allocate a command for storing the encoded message Command protoTx(DATA_COMMAND, uartTaskCommand); @@ -128,7 +138,8 @@ void ProtocolTask::Run(void * pvParams) // Encode in COBS cobs_encode_result cobsRes = cobs_encode(protoTx.GetDataPointer(), msgSize, cm.GetDataPointer(), cm.GetDataSize()); - if (cobsRes.status != COBS_ENCODE_OK) { + if (cobsRes.status != COBS_ENCODE_OK) + { protoTx.Reset(); SOAR_PRINT("WARNING: COBS encode failed in ProtocolTask TX case\n"); } @@ -137,7 +148,8 @@ void ProtocolTask::Run(void * pvParams) UARTTask::Inst().SendCommandReference(protoTx); break; } - case EVENT_UART_INTERRUPT_ARM_ERROR: { + case EVENT_UART_INTERRUPT_ARM_ERROR: + { // Attempt to receive data again ReceiveData(); break; @@ -162,7 +174,7 @@ bool ProtocolTask::ReceiveData() /** * @brief Sends a message to UART Task directly after wrapping it inside the message ID and checksum, and encoding with COBS */ -void ProtocolTask::SendData(uint8_t* data, uint16_t size, uint8_t msgId) +void ProtocolTask::SendData(uint8_t *data, uint16_t size, uint8_t msgId) { uint16_t msgSize = GET_COBS_MAX_LEN(size + PROTOCOL_OVERHEAD_BYTES); @@ -174,21 +186,22 @@ void ProtocolTask::SendData(uint8_t* data, uint16_t size, uint8_t msgId) arr[0] = msgId; memcpy(&(arr[1]), data, size); uint16_t chkSum = Utils::GetCRC16(arr, size + 1); - *((uint16_t*)&arr[preCobsSize - PROTOCOL_CHECKSUM_BYTES]) = chkSum; + *((uint16_t *)&arr[preCobsSize - PROTOCOL_CHECKSUM_BYTES]) = chkSum; // Send the data by wrapping in a COBS frame and sending direct to UART Task - Command protoTx(DATA_COMMAND, uartTaskCommand); + Command protoTx(DATA_COMMAND, uartTaskCommand); protoTx.AllocateData(msgSize); // Encode in COBS cobs_encode_result cobsEncRes = cobs_encode(protoTx.GetDataPointer(), msgSize, arr, preCobsSize); - if (cobsEncRes.status != COBS_ENCODE_OK) { + if (cobsEncRes.status != COBS_ENCODE_OK) + { protoTx.Reset(); SOAR_PRINT("WARNING: COBS encode failed in ProtocolTask NACK case\n"); } - SOAR_ASSERT(cobsEncRes.out_len+1 == msgSize, "COBS Size Mismatch %d %d\n", cobsEncRes.out_len+1, msgSize); + SOAR_ASSERT(cobsEncRes.out_len + 1 == msgSize, "COBS Size Mismatch %d %d\n", cobsEncRes.out_len + 1, msgSize); protoTx.GetDataPointer()[msgSize - 1] = 0x00; UARTTask::Inst().SendCommandReference(protoTx); } @@ -198,19 +211,19 @@ void ProtocolTask::SendData(uint8_t* data, uint16_t size, uint8_t msgId) */ void ProtocolTask::SendNACK(Proto::MessageID msgId, Proto::Node msgSource) { -// Proto::ControlMessage msg; -// msg.set_source(srcNode); -// msg.set_target(Proto::Node::NODE_RCU); -// Proto::AckNack nack; -// nack.set_acking_msg_source(msgSource); -// nack.set_acking_msg_id(msgId); -// msg.set_nack(nack); -// -// EmbeddedProto::WriteBufferFixedSize writeBuffer; -// msg.serialize(writeBuffer); -// -// // Send the control message -// SendData(writeBuffer.get_data(), writeBuffer.get_size(), (uint8_t)Proto::MessageID::MSG_CONTROL); + // Proto::ControlMessage msg; + // msg.set_source(srcNode); + // msg.set_target(Proto::Node::NODE_FSB); + // Proto::AckNack nack; + // nack.set_acking_msg_source(msgSource); + // nack.set_acking_msg_id(msgId); + // msg.set_nack(nack); + // + // EmbeddedProto::WriteBufferFixedSize writeBuffer; + // msg.serialize(writeBuffer); + // + // // Send the control message + // SendData(writeBuffer.get_data(), writeBuffer.get_size(), (uint8_t)Proto::MessageID::MSG_CONTROL); } /** @@ -220,31 +233,37 @@ void ProtocolTask::SendNACK(Proto::MessageID msgId, Proto::Node msgSource) void ProtocolTask::InterruptRxData(uint8_t errors) { // If we already have an unprocessed protocol message, ignore this byte - if (!isProtocolMsgReady) { + if (!isProtocolMsgReady) + { // Check COBS byte for end of message - if (protocolRxChar == '\0' || protocolMsgIdx == PROTOCOL_RX_BUFFER_SZ_BYTES) { - // If the message is of insufficient length, reset the buffer - if(protocolMsgIdx < PROTOCOL_MINIMUM_MESSAGE_LENGTH) { - protocolMsgIdx = 0; - isProtocolMsgReady = false; - } - else { - // Null terminate and process - protocolRxBuffer[protocolMsgIdx++] = '\0'; - isProtocolMsgReady = true; - - // Notify the protocol task - Command cm(PROTOCOL_COMMAND, EVENT_PROTOCOL_RX_COMPLETE); - bool res = qEvtQueue->SendFromISR(cm); - - // If we failed to send the event, we should reset the buffer, that way ProtocolTask doesn't stall - if (res == false) { - protocolMsgIdx = 0; - isProtocolMsgReady = false; - } - } + if (protocolRxChar == '\0' || protocolMsgIdx == PROTOCOL_RX_BUFFER_SZ_BYTES) + { + // If the message is of insufficient length, reset the buffer + if (protocolMsgIdx < PROTOCOL_MINIMUM_MESSAGE_LENGTH) + { + protocolMsgIdx = 0; + isProtocolMsgReady = false; + } + else + { + // Null terminate and process + protocolRxBuffer[protocolMsgIdx++] = '\0'; + isProtocolMsgReady = true; + + // Notify the protocol task + Command cm(PROTOCOL_COMMAND, EVENT_PROTOCOL_RX_COMPLETE); + bool res = qEvtQueue->SendFromISR(cm); + + // If we failed to send the event, we should reset the buffer, that way ProtocolTask doesn't stall + if (res == false) + { + protocolMsgIdx = 0; + isProtocolMsgReady = false; + } + } } - else { + else + { protocolRxBuffer[protocolMsgIdx++] = protocolRxChar; } } @@ -257,10 +276,10 @@ void ProtocolTask::InterruptRxData(uint8_t errors) * @brief Handle protocol message * @param Protocol message to handle, passed by reference */ -void ProtocolTask::HandleProtocolMessage(Command& cmd) +void ProtocolTask::HandleProtocolMessage(Command &cmd) { // Extract the message ID - uint8_t* buffer = cmd.GetDataPointer(); + uint8_t *buffer = cmd.GetDataPointer(); uint16_t bufSize = cmd.GetDataSize(); Proto::MessageID msgId = (Proto::MessageID)buffer[0]; @@ -274,7 +293,8 @@ void ProtocolTask::HandleProtocolMessage(Command& cmd) readBuffer.push(buffer[i]); // Switch for each message ID we can handle - switch (msgId) { + switch (msgId) + { case Proto::MessageID::MSG_COMMAND: HandleProtobufCommandMessage(readBuffer); break; @@ -296,7 +316,7 @@ void ProtocolTask::HandleProtocolMessage(Command& cmd) * @param writeBuffer The write buffer containing the serialized protobuf message * @param msgId The message ID of the message */ -void ProtocolTask::SendProtobufMessage(EmbeddedProto::WriteBufferFixedSize& writeBuffer, Proto::MessageID msgId) +void ProtocolTask::SendProtobufMessage(EmbeddedProto::WriteBufferFixedSize &writeBuffer, Proto::MessageID msgId) { // Note: This function runs inside the calling task SendData(writeBuffer.get_data(), writeBuffer.get_size(), (uint8_t)msgId); diff --git a/SoarProto/_C++/CommandMessage.hpp b/SoarProto/_C++/CommandMessage.hpp new file mode 100644 index 0000000..8f5ba6c --- /dev/null +++ b/SoarProto/_C++/CommandMessage.hpp @@ -0,0 +1,1711 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: CommandMessage.proto + */ + +// This file is generated. Please do not edit! +#ifndef COMMANDMESSAGE_H +#define COMMANDMESSAGE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Include external proto definitions +#include "CoreProto.h" + +namespace Proto { + +class FcbCommand final: public ::EmbeddedProto::MessageInterface +{ + public: + FcbCommand() = default; + FcbCommand(const FcbCommand& rhs ) + { + set_command_enum(rhs.get_command_enum()); + } + + FcbCommand(const FcbCommand&& rhs ) noexcept + { + set_command_enum(rhs.get_command_enum()); + } + + ~FcbCommand() override = default; + + enum class Command : uint32_t + { + RSC_FIRST_INVALID = 0, + RSC_ANY_TO_ABORT = 1, + RSC_OPEN_VENT = 2, + RSC_CLOSE_VENT = 3, + RSC_OPEN_DRAIN = 4, + RSC_CLOSE_DRAIN = 5, + RSC_MEV_CLOSE = 6, + RSC_GOTO_FILL = 7, + RSC_ARM_CONFIRM_1 = 8, + RSC_ARM_CONFIRM_2 = 9, + RSC_GOTO_ARM = 10, + RSC_GOTO_PRELAUNCH = 11, + RSC_POWER_TRANSITION_ONBOARD = 12, + RSC_POWER_TRANSITION_EXTERNAL = 13, + RSC_GOTO_IGNITION = 14, + RSC_IGNITION_TO_LAUNCH = 15, + RSC_LAUNCH_TO_BURN = 16, + RSC_BURN_TO_COAST = 17, + RSC_COAST_TO_DESCENT = 18, + RSC_DESCENT_TO_RECOVERY = 19, + RSC_GOTO_TEST = 20, + RSC_TEST_MEV_OPEN = 21, + RSC_TEST_MEV_ENABLE = 22, + RSC_TEST_MEV_DISABLE = 23, + RSC_NONE = 24 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + COMMAND_ENUM = 1 + }; + + FcbCommand& operator=(const FcbCommand& rhs) + { + set_command_enum(rhs.get_command_enum()); + return *this; + } + + FcbCommand& operator=(const FcbCommand&& rhs) noexcept + { + set_command_enum(rhs.get_command_enum()); + return *this; + } + + static constexpr char const* COMMAND_ENUM_NAME = "command_enum"; + inline void clear_command_enum() { command_enum_.clear(); } + inline void set_command_enum(const Command& value) { command_enum_ = value; } + inline void set_command_enum(const Command&& value) { command_enum_ = value; } + inline const Command& get_command_enum() const { return command_enum_.get(); } + inline Command command_enum() const { return command_enum_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != command_enum_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_enum_.serialize_with_id(static_cast(FieldNumber::COMMAND_ENUM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::COMMAND_ENUM: + return_value = command_enum_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_command_enum(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::COMMAND_ENUM: + name = COMMAND_ENUM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = command_enum_.to_string(left_chars, indent_level + 2, COMMAND_ENUM_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration command_enum_ = static_cast(0); + +}; + +class PbbCommand final: public ::EmbeddedProto::MessageInterface +{ + public: + PbbCommand() = default; + PbbCommand(const PbbCommand& rhs ) + { + set_command_enum(rhs.get_command_enum()); + } + + PbbCommand(const PbbCommand&& rhs ) noexcept + { + set_command_enum(rhs.get_command_enum()); + } + + ~PbbCommand() override = default; + + enum class Command : uint32_t + { + PBB_NONE = 0, + PBB_OPEN_MEV = 1, + PBB_CLOSE_MEV = 2, + PMB_LAST = 5 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + COMMAND_ENUM = 1 + }; + + PbbCommand& operator=(const PbbCommand& rhs) + { + set_command_enum(rhs.get_command_enum()); + return *this; + } + + PbbCommand& operator=(const PbbCommand&& rhs) noexcept + { + set_command_enum(rhs.get_command_enum()); + return *this; + } + + static constexpr char const* COMMAND_ENUM_NAME = "command_enum"; + inline void clear_command_enum() { command_enum_.clear(); } + inline void set_command_enum(const Command& value) { command_enum_ = value; } + inline void set_command_enum(const Command&& value) { command_enum_ = value; } + inline const Command& get_command_enum() const { return command_enum_.get(); } + inline Command command_enum() const { return command_enum_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != command_enum_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_enum_.serialize_with_id(static_cast(FieldNumber::COMMAND_ENUM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::COMMAND_ENUM: + return_value = command_enum_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_command_enum(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::COMMAND_ENUM: + name = COMMAND_ENUM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = command_enum_.to_string(left_chars, indent_level + 2, COMMAND_ENUM_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration command_enum_ = static_cast(0); + +}; + +class FsbCommand final: public ::EmbeddedProto::MessageInterface +{ + public: + FsbCommand() = default; + FsbCommand(const FsbCommand& rhs ) + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + } + + FsbCommand(const FsbCommand&& rhs ) noexcept + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + } + + ~FsbCommand() override = default; + + enum class Command : uint32_t + { + RCU_NONE = 0, + RCU_OPEN_AC1 = 3, + RCU_CLOSE_AC1 = 4, + RCU_OPEN_AC2 = 5, + RCU_CLOSE_AC2 = 6, + RCU_OPEN_PBV1 = 7, + RCU_CLOSE_PBV1 = 8, + RCU_OPEN_PBV2 = 9, + RCU_CLOSE_PBV2 = 10, + RCU_OPEN_PBV3 = 11, + RCU_CLOSE_PBV3 = 12, + RCU_OPEN_PBV4 = 13, + RCU_CLOSE_PBV4 = 14, + RCU_OPEN_SOL5 = 21, + RCU_CLOSE_SOL5 = 22, + RCU_OPEN_SOL6 = 23, + RCU_CLOSE_SOL6 = 24, + RCU_OPEN_SOL7 = 25, + RCU_CLOSE_SOL7 = 26, + RCU_OPEN_SOL8A = 27, + RCU_CLOSE_SOL8A = 28, + RCU_OPEN_SOL8B = 29, + RCU_CLOSE_SOL8B = 30, + RCU_TARE_NOS1_LOAD_CELL = 33, + RCU_TARE_NOS2_LOAD_CELL = 34, + RCU_CALIBRATE_NOS1_LOAD_CELL = 35, + RCU_CALIBRATE_NOS2_LOAD_CELL = 36, + RCU_IGNITE_PAD_BOX1 = 31, + RCU_IGNITE_PAD_BOX2 = 32, + RCU_KILL_PAD_BOX1 = 37, + RCU_KILL_PAD_BOX2 = 38, + RCU_LAST = 39 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + COMMAND_ENUM = 1, + COMMAND_PARAM = 2 + }; + + FsbCommand& operator=(const FsbCommand& rhs) + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + return *this; + } + + FsbCommand& operator=(const FsbCommand&& rhs) noexcept + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + return *this; + } + + static constexpr char const* COMMAND_ENUM_NAME = "command_enum"; + inline void clear_command_enum() { command_enum_.clear(); } + inline void set_command_enum(const Command& value) { command_enum_ = value; } + inline void set_command_enum(const Command&& value) { command_enum_ = value; } + inline const Command& get_command_enum() const { return command_enum_.get(); } + inline Command command_enum() const { return command_enum_.get(); } + + static constexpr char const* COMMAND_PARAM_NAME = "command_param"; + inline void clear_command_param() { command_param_.clear(); } + inline void set_command_param(const int32_t& value) { command_param_ = value; } + inline void set_command_param(const int32_t&& value) { command_param_ = value; } + inline int32_t& mutable_command_param() { return command_param_.get(); } + inline const int32_t& get_command_param() const { return command_param_.get(); } + inline int32_t command_param() const { return command_param_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != command_enum_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_enum_.serialize_with_id(static_cast(FieldNumber::COMMAND_ENUM), buffer, false); + } + + if((0 != command_param_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_param_.serialize_with_id(static_cast(FieldNumber::COMMAND_PARAM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::COMMAND_ENUM: + return_value = command_enum_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::COMMAND_PARAM: + return_value = command_param_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_command_enum(); + clear_command_param(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::COMMAND_ENUM: + name = COMMAND_ENUM_NAME; + break; + case FieldNumber::COMMAND_PARAM: + name = COMMAND_PARAM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = command_enum_.to_string(left_chars, indent_level + 2, COMMAND_ENUM_NAME, true); + left_chars = command_param_.to_string(left_chars, indent_level + 2, COMMAND_PARAM_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration command_enum_ = static_cast(0); + EmbeddedProto::int32 command_param_ = 0; + +}; + +class LrbCommand final: public ::EmbeddedProto::MessageInterface +{ + public: + LrbCommand() = default; + LrbCommand(const LrbCommand& rhs ) + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + } + + LrbCommand(const LrbCommand&& rhs ) noexcept + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + } + + ~LrbCommand() override = default; + + enum class Command : uint32_t + { + SOB_NONE = 0, + SOB_SLOW_SAMPLE_IR = 1, + SOB_FAST_SAMPLE_IR = 2, + SOB_TARE_LOAD_CELL = 3, + SOB_CALIBRATE_LOAD_CELL = 4, + SOB_LAST = 5 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + COMMAND_ENUM = 1, + COMMAND_PARAM = 2 + }; + + LrbCommand& operator=(const LrbCommand& rhs) + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + return *this; + } + + LrbCommand& operator=(const LrbCommand&& rhs) noexcept + { + set_command_enum(rhs.get_command_enum()); + set_command_param(rhs.get_command_param()); + return *this; + } + + static constexpr char const* COMMAND_ENUM_NAME = "command_enum"; + inline void clear_command_enum() { command_enum_.clear(); } + inline void set_command_enum(const Command& value) { command_enum_ = value; } + inline void set_command_enum(const Command&& value) { command_enum_ = value; } + inline const Command& get_command_enum() const { return command_enum_.get(); } + inline Command command_enum() const { return command_enum_.get(); } + + static constexpr char const* COMMAND_PARAM_NAME = "command_param"; + inline void clear_command_param() { command_param_.clear(); } + inline void set_command_param(const int32_t& value) { command_param_ = value; } + inline void set_command_param(const int32_t&& value) { command_param_ = value; } + inline int32_t& mutable_command_param() { return command_param_.get(); } + inline const int32_t& get_command_param() const { return command_param_.get(); } + inline int32_t command_param() const { return command_param_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != command_enum_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_enum_.serialize_with_id(static_cast(FieldNumber::COMMAND_ENUM), buffer, false); + } + + if((0 != command_param_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = command_param_.serialize_with_id(static_cast(FieldNumber::COMMAND_PARAM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::COMMAND_ENUM: + return_value = command_enum_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::COMMAND_PARAM: + return_value = command_param_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_command_enum(); + clear_command_param(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::COMMAND_ENUM: + name = COMMAND_ENUM_NAME; + break; + case FieldNumber::COMMAND_PARAM: + name = COMMAND_PARAM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = command_enum_.to_string(left_chars, indent_level + 2, COMMAND_ENUM_NAME, true); + left_chars = command_param_.to_string(left_chars, indent_level + 2, COMMAND_PARAM_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration command_enum_ = static_cast(0); + EmbeddedProto::int32 command_param_ = 0; + +}; + +class CommandMessage final: public ::EmbeddedProto::MessageInterface +{ + public: + CommandMessage() = default; + CommandMessage(const CommandMessage& rhs ) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FCB_COMMAND: + set_fcb_command(rhs.get_fcb_command()); + break; + + case FieldNumber::PBB_COMMAND: + set_pbb_command(rhs.get_pbb_command()); + break; + + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + case FieldNumber::LRB_COMMAND: + set_lrb_command(rhs.get_lrb_command()); + break; + + default: + break; + } + + } + + CommandMessage(const CommandMessage&& rhs ) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FCB_COMMAND: + set_fcb_command(rhs.get_fcb_command()); + break; + + case FieldNumber::PBB_COMMAND: + set_pbb_command(rhs.get_pbb_command()); + break; + + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + case FieldNumber::LRB_COMMAND: + set_lrb_command(rhs.get_lrb_command()); + break; + + default: + break; + } + + } + + ~CommandMessage() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SOURCE = 1, + TARGET = 2, + SOURCE_SEQUENCE_NUM = 3, + FCB_COMMAND = 4, + PBB_COMMAND = 5, + FSB_COMMAND = 6, + LRB_COMMAND = 7 + }; + + CommandMessage& operator=(const CommandMessage& rhs) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FCB_COMMAND: + set_fcb_command(rhs.get_fcb_command()); + break; + + case FieldNumber::PBB_COMMAND: + set_pbb_command(rhs.get_pbb_command()); + break; + + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + case FieldNumber::LRB_COMMAND: + set_lrb_command(rhs.get_lrb_command()); + break; + + default: + break; + } + + return *this; + } + + CommandMessage& operator=(const CommandMessage&& rhs) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FCB_COMMAND: + set_fcb_command(rhs.get_fcb_command()); + break; + + case FieldNumber::PBB_COMMAND: + set_pbb_command(rhs.get_pbb_command()); + break; + + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + case FieldNumber::LRB_COMMAND: + set_lrb_command(rhs.get_lrb_command()); + break; + + default: + break; + } + + return *this; + } + + static constexpr char const* SOURCE_NAME = "source"; + inline void clear_source() { source_.clear(); } + inline void set_source(const Node& value) { source_ = value; } + inline void set_source(const Node&& value) { source_ = value; } + inline const Node& get_source() const { return source_.get(); } + inline Node source() const { return source_.get(); } + + static constexpr char const* TARGET_NAME = "target"; + inline void clear_target() { target_.clear(); } + inline void set_target(const Node& value) { target_ = value; } + inline void set_target(const Node&& value) { target_ = value; } + inline const Node& get_target() const { return target_.get(); } + inline Node target() const { return target_.get(); } + + static constexpr char const* SOURCE_SEQUENCE_NUM_NAME = "source_sequence_num"; + inline void clear_source_sequence_num() { source_sequence_num_.clear(); } + inline void set_source_sequence_num(const uint32_t& value) { source_sequence_num_ = value; } + inline void set_source_sequence_num(const uint32_t&& value) { source_sequence_num_ = value; } + inline uint32_t& mutable_source_sequence_num() { return source_sequence_num_.get(); } + inline const uint32_t& get_source_sequence_num() const { return source_sequence_num_.get(); } + inline uint32_t source_sequence_num() const { return source_sequence_num_.get(); } + + FieldNumber get_which_message() const { return which_message_; } + + static constexpr char const* FCB_COMMAND_NAME = "fcb_command"; + inline bool has_fcb_command() const + { + return FieldNumber::FCB_COMMAND == which_message_; + } + inline void clear_fcb_command() + { + if(FieldNumber::FCB_COMMAND == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.fcb_command_.~FcbCommand(); + } + } + inline void set_fcb_command(const FcbCommand& value) + { + if(FieldNumber::FCB_COMMAND != which_message_) + { + init_message(FieldNumber::FCB_COMMAND); + } + message_.fcb_command_ = value; + } + inline void set_fcb_command(const FcbCommand&& value) + { + if(FieldNumber::FCB_COMMAND != which_message_) + { + init_message(FieldNumber::FCB_COMMAND); + } + message_.fcb_command_ = value; + } + inline FcbCommand& mutable_fcb_command() + { + if(FieldNumber::FCB_COMMAND != which_message_) + { + init_message(FieldNumber::FCB_COMMAND); + } + return message_.fcb_command_; + } + inline const FcbCommand& get_fcb_command() const { return message_.fcb_command_; } + inline const FcbCommand& fcb_command() const { return message_.fcb_command_; } + + static constexpr char const* PBB_COMMAND_NAME = "pbb_command"; + inline bool has_pbb_command() const + { + return FieldNumber::PBB_COMMAND == which_message_; + } + inline void clear_pbb_command() + { + if(FieldNumber::PBB_COMMAND == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.pbb_command_.~PbbCommand(); + } + } + inline void set_pbb_command(const PbbCommand& value) + { + if(FieldNumber::PBB_COMMAND != which_message_) + { + init_message(FieldNumber::PBB_COMMAND); + } + message_.pbb_command_ = value; + } + inline void set_pbb_command(const PbbCommand&& value) + { + if(FieldNumber::PBB_COMMAND != which_message_) + { + init_message(FieldNumber::PBB_COMMAND); + } + message_.pbb_command_ = value; + } + inline PbbCommand& mutable_pbb_command() + { + if(FieldNumber::PBB_COMMAND != which_message_) + { + init_message(FieldNumber::PBB_COMMAND); + } + return message_.pbb_command_; + } + inline const PbbCommand& get_pbb_command() const { return message_.pbb_command_; } + inline const PbbCommand& pbb_command() const { return message_.pbb_command_; } + + static constexpr char const* FSB_COMMAND_NAME = "fsb_command"; + inline bool has_fsb_command() const + { + return FieldNumber::FSB_COMMAND == which_message_; + } + inline void clear_fsb_command() + { + if(FieldNumber::FSB_COMMAND == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.fsb_command_.~FsbCommand(); + } + } + inline void set_fsb_command(const FsbCommand& value) + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + message_.fsb_command_ = value; + } + inline void set_fsb_command(const FsbCommand&& value) + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + message_.fsb_command_ = value; + } + inline FsbCommand& mutable_fsb_command() + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + return message_.fsb_command_; + } + inline const FsbCommand& get_fsb_command() const { return message_.fsb_command_; } + inline const FsbCommand& fsb_command() const { return message_.fsb_command_; } + + static constexpr char const* LRB_COMMAND_NAME = "lrb_command"; + inline bool has_lrb_command() const + { + return FieldNumber::LRB_COMMAND == which_message_; + } + inline void clear_lrb_command() + { + if(FieldNumber::LRB_COMMAND == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.lrb_command_.~LrbCommand(); + } + } + inline void set_lrb_command(const LrbCommand& value) + { + if(FieldNumber::LRB_COMMAND != which_message_) + { + init_message(FieldNumber::LRB_COMMAND); + } + message_.lrb_command_ = value; + } + inline void set_lrb_command(const LrbCommand&& value) + { + if(FieldNumber::LRB_COMMAND != which_message_) + { + init_message(FieldNumber::LRB_COMMAND); + } + message_.lrb_command_ = value; + } + inline LrbCommand& mutable_lrb_command() + { + if(FieldNumber::LRB_COMMAND != which_message_) + { + init_message(FieldNumber::LRB_COMMAND); + } + return message_.lrb_command_; + } + inline const LrbCommand& get_lrb_command() const { return message_.lrb_command_; } + inline const LrbCommand& lrb_command() const { return message_.lrb_command_; } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != source_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_.serialize_with_id(static_cast(FieldNumber::SOURCE), buffer, false); + } + + if((static_cast(0) != target_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = target_.serialize_with_id(static_cast(FieldNumber::TARGET), buffer, false); + } + + if((0U != source_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_sequence_num_.serialize_with_id(static_cast(FieldNumber::SOURCE_SEQUENCE_NUM), buffer, false); + } + + switch(which_message_) + { + case FieldNumber::FCB_COMMAND: + if(has_fcb_command() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.fcb_command_.serialize_with_id(static_cast(FieldNumber::FCB_COMMAND), buffer, true); + } + break; + + case FieldNumber::PBB_COMMAND: + if(has_pbb_command() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.pbb_command_.serialize_with_id(static_cast(FieldNumber::PBB_COMMAND), buffer, true); + } + break; + + case FieldNumber::FSB_COMMAND: + if(has_fsb_command() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.fsb_command_.serialize_with_id(static_cast(FieldNumber::FSB_COMMAND), buffer, true); + } + break; + + case FieldNumber::LRB_COMMAND: + if(has_lrb_command() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.lrb_command_.serialize_with_id(static_cast(FieldNumber::LRB_COMMAND), buffer, true); + } + break; + + default: + break; + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SOURCE: + return_value = source_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TARGET: + return_value = target_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOURCE_SEQUENCE_NUM: + return_value = source_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::FCB_COMMAND: + case FieldNumber::PBB_COMMAND: + case FieldNumber::FSB_COMMAND: + case FieldNumber::LRB_COMMAND: + return_value = deserialize_message(id_tag, buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_source(); + clear_target(); + clear_source_sequence_num(); + clear_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SOURCE: + name = SOURCE_NAME; + break; + case FieldNumber::TARGET: + name = TARGET_NAME; + break; + case FieldNumber::SOURCE_SEQUENCE_NUM: + name = SOURCE_SEQUENCE_NUM_NAME; + break; + case FieldNumber::FCB_COMMAND: + name = FCB_COMMAND_NAME; + break; + case FieldNumber::PBB_COMMAND: + name = PBB_COMMAND_NAME; + break; + case FieldNumber::FSB_COMMAND: + name = FSB_COMMAND_NAME; + break; + case FieldNumber::LRB_COMMAND: + name = LRB_COMMAND_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = source_.to_string(left_chars, indent_level + 2, SOURCE_NAME, true); + left_chars = target_.to_string(left_chars, indent_level + 2, TARGET_NAME, false); + left_chars = source_sequence_num_.to_string(left_chars, indent_level + 2, SOURCE_SEQUENCE_NUM_NAME, false); + left_chars = to_string_message(left_chars, indent_level + 2, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration source_ = static_cast(0); + EmbeddedProto::enumeration target_ = static_cast(0); + EmbeddedProto::uint32 source_sequence_num_ = 0U; + + FieldNumber which_message_ = FieldNumber::NOT_SET; + union message + { + message() {} + ~message() {} + FcbCommand fcb_command_; + PbbCommand pbb_command_; + FsbCommand fsb_command_; + LrbCommand lrb_command_; + }; + message message_; + + void init_message(const FieldNumber field_id) + { + if(FieldNumber::NOT_SET != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + // C++11 unions only support nontrivial members when you explicitly call the placement new statement. + switch(field_id) + { + case FieldNumber::FCB_COMMAND: + new(&message_.fcb_command_) FcbCommand; + break; + + case FieldNumber::PBB_COMMAND: + new(&message_.pbb_command_) PbbCommand; + break; + + case FieldNumber::FSB_COMMAND: + new(&message_.fsb_command_) FsbCommand; + break; + + case FieldNumber::LRB_COMMAND: + new(&message_.lrb_command_) LrbCommand; + break; + + default: + break; + } + + which_message_ = field_id; + } + + void clear_message() + { + switch(which_message_) + { + case FieldNumber::FCB_COMMAND: + ::EmbeddedProto::destroy_at(&message_.fcb_command_); + break; + case FieldNumber::PBB_COMMAND: + ::EmbeddedProto::destroy_at(&message_.pbb_command_); + break; + case FieldNumber::FSB_COMMAND: + ::EmbeddedProto::destroy_at(&message_.fsb_command_); + break; + case FieldNumber::LRB_COMMAND: + ::EmbeddedProto::destroy_at(&message_.lrb_command_); + break; + default: + break; + } + which_message_ = FieldNumber::NOT_SET; + } + + ::EmbeddedProto::Error deserialize_message(const FieldNumber field_id, + ::EmbeddedProto::ReadBufferInterface& buffer, + const ::EmbeddedProto::WireFormatter::WireType wire_type) + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(field_id != which_message_) + { + init_message(field_id); + } + + switch(which_message_) + { + case FieldNumber::FCB_COMMAND: + return_value = message_.fcb_command_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PBB_COMMAND: + return_value = message_.pbb_command_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::FSB_COMMAND: + return_value = message_.fsb_command_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::LRB_COMMAND: + return_value = message_.lrb_command_.deserialize_check_type(buffer, wire_type); + break; + default: + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS != return_value) + { + clear_message(); + } + return return_value; + } + +#ifdef MSG_TO_STRING + ::EmbeddedProto::string_view to_string_message(::EmbeddedProto::string_view& str, const uint32_t indent_level, const bool first_field) const + { + ::EmbeddedProto::string_view left_chars = str; + + switch(which_message_) + { + case FieldNumber::FCB_COMMAND: + left_chars = message_.fcb_command_.to_string(left_chars, indent_level, FCB_COMMAND_NAME, first_field); + break; + case FieldNumber::PBB_COMMAND: + left_chars = message_.pbb_command_.to_string(left_chars, indent_level, PBB_COMMAND_NAME, first_field); + break; + case FieldNumber::FSB_COMMAND: + left_chars = message_.fsb_command_.to_string(left_chars, indent_level, FSB_COMMAND_NAME, first_field); + break; + case FieldNumber::LRB_COMMAND: + left_chars = message_.lrb_command_.to_string(left_chars, indent_level, LRB_COMMAND_NAME, first_field); + break; + default: + break; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING +}; + +} // End of namespace Proto +#endif // COMMANDMESSAGE_H \ No newline at end of file diff --git a/SoarProto/_C++/CommandMessages.hpp b/SoarProto/_C++/CommandMessages.hpp new file mode 100644 index 0000000..59d0646 --- /dev/null +++ b/SoarProto/_C++/CommandMessages.hpp @@ -0,0 +1,663 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: CommandMessages.proto + */ + +// This file is generated. Please do not edit! +#ifndef COMMANDMESSAGES_H +#define COMMANDMESSAGES_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Include external proto definitions + +namespace Proto { + +class FsbCommand final: public ::EmbeddedProto::MessageInterface +{ + public: + FsbCommand() = default; + FsbCommand(const FsbCommand& rhs ) + { + set_fsb_message(rhs.get_fsb_message()); + } + + FsbCommand(const FsbCommand&& rhs ) noexcept + { + set_fsb_message(rhs.get_fsb_message()); + } + + ~FsbCommand() override = default; + + enum class Command : uint32_t + { + START_LOGGING = 0, + STOP_LOGGING = 1, + SEND_FILES = 2 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + FSB_MESSAGE = 1 + }; + + FsbCommand& operator=(const FsbCommand& rhs) + { + set_fsb_message(rhs.get_fsb_message()); + return *this; + } + + FsbCommand& operator=(const FsbCommand&& rhs) noexcept + { + set_fsb_message(rhs.get_fsb_message()); + return *this; + } + + static constexpr char const* FSB_MESSAGE_NAME = "fsb_message"; + inline void clear_fsb_message() { fsb_message_.clear(); } + inline void set_fsb_message(const Command& value) { fsb_message_ = value; } + inline void set_fsb_message(const Command&& value) { fsb_message_ = value; } + inline const Command& get_fsb_message() const { return fsb_message_.get(); } + inline Command fsb_message() const { return fsb_message_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != fsb_message_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = fsb_message_.serialize_with_id(static_cast(FieldNumber::FSB_MESSAGE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::FSB_MESSAGE: + return_value = fsb_message_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_fsb_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::FSB_MESSAGE: + name = FSB_MESSAGE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = fsb_message_.to_string(left_chars, indent_level + 2, FSB_MESSAGE_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration fsb_message_ = static_cast(0); + +}; + +class CommandMessages final: public ::EmbeddedProto::MessageInterface +{ + public: + CommandMessages() = default; + CommandMessages(const CommandMessages& rhs ) + { + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + default: + break; + } + + } + + CommandMessages(const CommandMessages&& rhs ) noexcept + { + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + default: + break; + } + + } + + ~CommandMessages() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SOURCE_SEQUENCE_NUM = 1, + FSB_COMMAND = 2 + }; + + CommandMessages& operator=(const CommandMessages& rhs) + { + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + default: + break; + } + + return *this; + } + + CommandMessages& operator=(const CommandMessages&& rhs) noexcept + { + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::FSB_COMMAND: + set_fsb_command(rhs.get_fsb_command()); + break; + + default: + break; + } + + return *this; + } + + static constexpr char const* SOURCE_SEQUENCE_NUM_NAME = "source_sequence_num"; + inline void clear_source_sequence_num() { source_sequence_num_.clear(); } + inline void set_source_sequence_num(const uint32_t& value) { source_sequence_num_ = value; } + inline void set_source_sequence_num(const uint32_t&& value) { source_sequence_num_ = value; } + inline uint32_t& mutable_source_sequence_num() { return source_sequence_num_.get(); } + inline const uint32_t& get_source_sequence_num() const { return source_sequence_num_.get(); } + inline uint32_t source_sequence_num() const { return source_sequence_num_.get(); } + + FieldNumber get_which_message() const { return which_message_; } + + static constexpr char const* FSB_COMMAND_NAME = "fsb_command"; + inline bool has_fsb_command() const + { + return FieldNumber::FSB_COMMAND == which_message_; + } + inline void clear_fsb_command() + { + if(FieldNumber::FSB_COMMAND == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.fsb_command_.~FsbCommand(); + } + } + inline void set_fsb_command(const FsbCommand& value) + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + message_.fsb_command_ = value; + } + inline void set_fsb_command(const FsbCommand&& value) + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + message_.fsb_command_ = value; + } + inline FsbCommand& mutable_fsb_command() + { + if(FieldNumber::FSB_COMMAND != which_message_) + { + init_message(FieldNumber::FSB_COMMAND); + } + return message_.fsb_command_; + } + inline const FsbCommand& get_fsb_command() const { return message_.fsb_command_; } + inline const FsbCommand& fsb_command() const { return message_.fsb_command_; } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != source_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_sequence_num_.serialize_with_id(static_cast(FieldNumber::SOURCE_SEQUENCE_NUM), buffer, false); + } + + switch(which_message_) + { + case FieldNumber::FSB_COMMAND: + if(has_fsb_command() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.fsb_command_.serialize_with_id(static_cast(FieldNumber::FSB_COMMAND), buffer, true); + } + break; + + default: + break; + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SOURCE_SEQUENCE_NUM: + return_value = source_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::FSB_COMMAND: + return_value = deserialize_message(id_tag, buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_source_sequence_num(); + clear_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SOURCE_SEQUENCE_NUM: + name = SOURCE_SEQUENCE_NUM_NAME; + break; + case FieldNumber::FSB_COMMAND: + name = FSB_COMMAND_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = source_sequence_num_.to_string(left_chars, indent_level + 2, SOURCE_SEQUENCE_NUM_NAME, true); + left_chars = to_string_message(left_chars, indent_level + 2, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 source_sequence_num_ = 0U; + + FieldNumber which_message_ = FieldNumber::NOT_SET; + union message + { + message() {} + ~message() {} + FsbCommand fsb_command_; + }; + message message_; + + void init_message(const FieldNumber field_id) + { + if(FieldNumber::NOT_SET != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + // C++11 unions only support nontrivial members when you explicitly call the placement new statement. + switch(field_id) + { + case FieldNumber::FSB_COMMAND: + new(&message_.fsb_command_) FsbCommand; + break; + + default: + break; + } + + which_message_ = field_id; + } + + void clear_message() + { + switch(which_message_) + { + case FieldNumber::FSB_COMMAND: + ::EmbeddedProto::destroy_at(&message_.fsb_command_); + break; + default: + break; + } + which_message_ = FieldNumber::NOT_SET; + } + + ::EmbeddedProto::Error deserialize_message(const FieldNumber field_id, + ::EmbeddedProto::ReadBufferInterface& buffer, + const ::EmbeddedProto::WireFormatter::WireType wire_type) + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(field_id != which_message_) + { + init_message(field_id); + } + + switch(which_message_) + { + case FieldNumber::FSB_COMMAND: + return_value = message_.fsb_command_.deserialize_check_type(buffer, wire_type); + break; + default: + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS != return_value) + { + clear_message(); + } + return return_value; + } + +#ifdef MSG_TO_STRING + ::EmbeddedProto::string_view to_string_message(::EmbeddedProto::string_view& str, const uint32_t indent_level, const bool first_field) const + { + ::EmbeddedProto::string_view left_chars = str; + + switch(which_message_) + { + case FieldNumber::FSB_COMMAND: + left_chars = message_.fsb_command_.to_string(left_chars, indent_level, FSB_COMMAND_NAME, first_field); + break; + default: + break; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING +}; + +} // End of namespace Proto +#endif // COMMANDMESSAGES_H \ No newline at end of file diff --git a/SoarProto/_C++/ControlMessage.hpp b/SoarProto/_C++/ControlMessage.hpp new file mode 100644 index 0000000..12edd17 --- /dev/null +++ b/SoarProto/_C++/ControlMessage.hpp @@ -0,0 +1,2862 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: ControlMessage.proto + */ + +// This file is generated. Please do not edit! +#ifndef CONTROLMESSAGE_H +#define CONTROLMESSAGE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Include external proto definitions +#include "CoreProto.h" + +namespace Proto { + +class AckNack final: public ::EmbeddedProto::MessageInterface +{ + public: + AckNack() = default; + AckNack(const AckNack& rhs ) + { + set_acking_msg_source(rhs.get_acking_msg_source()); + set_acking_msg_id(rhs.get_acking_msg_id()); + set_acking_sequence_num(rhs.get_acking_sequence_num()); + } + + AckNack(const AckNack&& rhs ) noexcept + { + set_acking_msg_source(rhs.get_acking_msg_source()); + set_acking_msg_id(rhs.get_acking_msg_id()); + set_acking_sequence_num(rhs.get_acking_sequence_num()); + } + + ~AckNack() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + ACKING_MSG_SOURCE = 1, + ACKING_MSG_ID = 2, + ACKING_SEQUENCE_NUM = 3 + }; + + AckNack& operator=(const AckNack& rhs) + { + set_acking_msg_source(rhs.get_acking_msg_source()); + set_acking_msg_id(rhs.get_acking_msg_id()); + set_acking_sequence_num(rhs.get_acking_sequence_num()); + return *this; + } + + AckNack& operator=(const AckNack&& rhs) noexcept + { + set_acking_msg_source(rhs.get_acking_msg_source()); + set_acking_msg_id(rhs.get_acking_msg_id()); + set_acking_sequence_num(rhs.get_acking_sequence_num()); + return *this; + } + + static constexpr char const* ACKING_MSG_SOURCE_NAME = "acking_msg_source"; + inline void clear_acking_msg_source() { acking_msg_source_.clear(); } + inline void set_acking_msg_source(const Node& value) { acking_msg_source_ = value; } + inline void set_acking_msg_source(const Node&& value) { acking_msg_source_ = value; } + inline const Node& get_acking_msg_source() const { return acking_msg_source_.get(); } + inline Node acking_msg_source() const { return acking_msg_source_.get(); } + + static constexpr char const* ACKING_MSG_ID_NAME = "acking_msg_id"; + inline void clear_acking_msg_id() { acking_msg_id_.clear(); } + inline void set_acking_msg_id(const MessageID& value) { acking_msg_id_ = value; } + inline void set_acking_msg_id(const MessageID&& value) { acking_msg_id_ = value; } + inline const MessageID& get_acking_msg_id() const { return acking_msg_id_.get(); } + inline MessageID acking_msg_id() const { return acking_msg_id_.get(); } + + static constexpr char const* ACKING_SEQUENCE_NUM_NAME = "acking_sequence_num"; + inline void clear_acking_sequence_num() { acking_sequence_num_.clear(); } + inline void set_acking_sequence_num(const uint32_t& value) { acking_sequence_num_ = value; } + inline void set_acking_sequence_num(const uint32_t&& value) { acking_sequence_num_ = value; } + inline uint32_t& mutable_acking_sequence_num() { return acking_sequence_num_.get(); } + inline const uint32_t& get_acking_sequence_num() const { return acking_sequence_num_.get(); } + inline uint32_t acking_sequence_num() const { return acking_sequence_num_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != acking_msg_source_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = acking_msg_source_.serialize_with_id(static_cast(FieldNumber::ACKING_MSG_SOURCE), buffer, false); + } + + if((static_cast(0) != acking_msg_id_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = acking_msg_id_.serialize_with_id(static_cast(FieldNumber::ACKING_MSG_ID), buffer, false); + } + + if((0U != acking_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = acking_sequence_num_.serialize_with_id(static_cast(FieldNumber::ACKING_SEQUENCE_NUM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::ACKING_MSG_SOURCE: + return_value = acking_msg_source_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACKING_MSG_ID: + return_value = acking_msg_id_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACKING_SEQUENCE_NUM: + return_value = acking_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_acking_msg_source(); + clear_acking_msg_id(); + clear_acking_sequence_num(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::ACKING_MSG_SOURCE: + name = ACKING_MSG_SOURCE_NAME; + break; + case FieldNumber::ACKING_MSG_ID: + name = ACKING_MSG_ID_NAME; + break; + case FieldNumber::ACKING_SEQUENCE_NUM: + name = ACKING_SEQUENCE_NUM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = acking_msg_source_.to_string(left_chars, indent_level + 2, ACKING_MSG_SOURCE_NAME, true); + left_chars = acking_msg_id_.to_string(left_chars, indent_level + 2, ACKING_MSG_ID_NAME, false); + left_chars = acking_sequence_num_.to_string(left_chars, indent_level + 2, ACKING_SEQUENCE_NUM_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration acking_msg_source_ = static_cast(0); + EmbeddedProto::enumeration acking_msg_id_ = static_cast(0); + EmbeddedProto::uint32 acking_sequence_num_ = 0U; + +}; + +class FastLog final: public ::EmbeddedProto::MessageInterface +{ + public: + FastLog() = default; + FastLog(const FastLog& rhs ) + { + set_cmd(rhs.get_cmd()); + } + + FastLog(const FastLog&& rhs ) noexcept + { + set_cmd(rhs.get_cmd()); + } + + ~FastLog() override = default; + + enum class FastLogCommand : uint32_t + { + FL_PEND = 0, + FL_START = 1, + FL_SEND = 2, + FL_RESET = 3 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + CMD = 1 + }; + + FastLog& operator=(const FastLog& rhs) + { + set_cmd(rhs.get_cmd()); + return *this; + } + + FastLog& operator=(const FastLog&& rhs) noexcept + { + set_cmd(rhs.get_cmd()); + return *this; + } + + static constexpr char const* CMD_NAME = "cmd"; + inline void clear_cmd() { cmd_.clear(); } + inline void set_cmd(const FastLogCommand& value) { cmd_ = value; } + inline void set_cmd(const FastLogCommand&& value) { cmd_ = value; } + inline const FastLogCommand& get_cmd() const { return cmd_.get(); } + inline FastLogCommand cmd() const { return cmd_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != cmd_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = cmd_.serialize_with_id(static_cast(FieldNumber::CMD), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::CMD: + return_value = cmd_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_cmd(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::CMD: + name = CMD_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = cmd_.to_string(left_chars, indent_level + 2, CMD_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration cmd_ = static_cast(0); + +}; + +class Heartbeat final: public ::EmbeddedProto::MessageInterface +{ + public: + Heartbeat() = default; + Heartbeat(const Heartbeat& rhs ) + { + set_hb_response_sequence_num(rhs.get_hb_response_sequence_num()); + } + + Heartbeat(const Heartbeat&& rhs ) noexcept + { + set_hb_response_sequence_num(rhs.get_hb_response_sequence_num()); + } + + ~Heartbeat() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + HB_RESPONSE_SEQUENCE_NUM = 1 + }; + + Heartbeat& operator=(const Heartbeat& rhs) + { + set_hb_response_sequence_num(rhs.get_hb_response_sequence_num()); + return *this; + } + + Heartbeat& operator=(const Heartbeat&& rhs) noexcept + { + set_hb_response_sequence_num(rhs.get_hb_response_sequence_num()); + return *this; + } + + static constexpr char const* HB_RESPONSE_SEQUENCE_NUM_NAME = "hb_response_sequence_num"; + inline void clear_hb_response_sequence_num() { hb_response_sequence_num_.clear(); } + inline void set_hb_response_sequence_num(const uint32_t& value) { hb_response_sequence_num_ = value; } + inline void set_hb_response_sequence_num(const uint32_t&& value) { hb_response_sequence_num_ = value; } + inline uint32_t& mutable_hb_response_sequence_num() { return hb_response_sequence_num_.get(); } + inline const uint32_t& get_hb_response_sequence_num() const { return hb_response_sequence_num_.get(); } + inline uint32_t hb_response_sequence_num() const { return hb_response_sequence_num_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != hb_response_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = hb_response_sequence_num_.serialize_with_id(static_cast(FieldNumber::HB_RESPONSE_SEQUENCE_NUM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::HB_RESPONSE_SEQUENCE_NUM: + return_value = hb_response_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_hb_response_sequence_num(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::HB_RESPONSE_SEQUENCE_NUM: + name = HB_RESPONSE_SEQUENCE_NUM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = hb_response_sequence_num_.to_string(left_chars, indent_level + 2, HB_RESPONSE_SEQUENCE_NUM_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 hb_response_sequence_num_ = 0U; + +}; + +class HeartbeatState final: public ::EmbeddedProto::MessageInterface +{ + public: + HeartbeatState() = default; + HeartbeatState(const HeartbeatState& rhs ) + { + set_timer_state(rhs.get_timer_state()); + set_timer_period(rhs.get_timer_period()); + set_timer_remaining(rhs.get_timer_remaining()); + } + + HeartbeatState(const HeartbeatState&& rhs ) noexcept + { + set_timer_state(rhs.get_timer_state()); + set_timer_period(rhs.get_timer_period()); + set_timer_remaining(rhs.get_timer_remaining()); + } + + ~HeartbeatState() override = default; + + enum class TimerState : uint32_t + { + UNINITIALIZED = 0, + COUNTING = 1, + PAUSED = 2, + COMPLETE = 3 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TIMER_STATE = 1, + TIMER_PERIOD = 2, + TIMER_REMAINING = 3 + }; + + HeartbeatState& operator=(const HeartbeatState& rhs) + { + set_timer_state(rhs.get_timer_state()); + set_timer_period(rhs.get_timer_period()); + set_timer_remaining(rhs.get_timer_remaining()); + return *this; + } + + HeartbeatState& operator=(const HeartbeatState&& rhs) noexcept + { + set_timer_state(rhs.get_timer_state()); + set_timer_period(rhs.get_timer_period()); + set_timer_remaining(rhs.get_timer_remaining()); + return *this; + } + + static constexpr char const* TIMER_STATE_NAME = "timer_state"; + inline void clear_timer_state() { timer_state_.clear(); } + inline void set_timer_state(const TimerState& value) { timer_state_ = value; } + inline void set_timer_state(const TimerState&& value) { timer_state_ = value; } + inline const TimerState& get_timer_state() const { return timer_state_.get(); } + inline TimerState timer_state() const { return timer_state_.get(); } + + static constexpr char const* TIMER_PERIOD_NAME = "timer_period"; + inline void clear_timer_period() { timer_period_.clear(); } + inline void set_timer_period(const uint32_t& value) { timer_period_ = value; } + inline void set_timer_period(const uint32_t&& value) { timer_period_ = value; } + inline uint32_t& mutable_timer_period() { return timer_period_.get(); } + inline const uint32_t& get_timer_period() const { return timer_period_.get(); } + inline uint32_t timer_period() const { return timer_period_.get(); } + + static constexpr char const* TIMER_REMAINING_NAME = "timer_remaining"; + inline void clear_timer_remaining() { timer_remaining_.clear(); } + inline void set_timer_remaining(const uint32_t& value) { timer_remaining_ = value; } + inline void set_timer_remaining(const uint32_t&& value) { timer_remaining_ = value; } + inline uint32_t& mutable_timer_remaining() { return timer_remaining_.get(); } + inline const uint32_t& get_timer_remaining() const { return timer_remaining_.get(); } + inline uint32_t timer_remaining() const { return timer_remaining_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != timer_state_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = timer_state_.serialize_with_id(static_cast(FieldNumber::TIMER_STATE), buffer, false); + } + + if((0U != timer_period_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = timer_period_.serialize_with_id(static_cast(FieldNumber::TIMER_PERIOD), buffer, false); + } + + if((0U != timer_remaining_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = timer_remaining_.serialize_with_id(static_cast(FieldNumber::TIMER_REMAINING), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TIMER_STATE: + return_value = timer_state_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TIMER_PERIOD: + return_value = timer_period_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TIMER_REMAINING: + return_value = timer_remaining_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_timer_state(); + clear_timer_period(); + clear_timer_remaining(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TIMER_STATE: + name = TIMER_STATE_NAME; + break; + case FieldNumber::TIMER_PERIOD: + name = TIMER_PERIOD_NAME; + break; + case FieldNumber::TIMER_REMAINING: + name = TIMER_REMAINING_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = timer_state_.to_string(left_chars, indent_level + 2, TIMER_STATE_NAME, true); + left_chars = timer_period_.to_string(left_chars, indent_level + 2, TIMER_PERIOD_NAME, false); + left_chars = timer_remaining_.to_string(left_chars, indent_level + 2, TIMER_REMAINING_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration timer_state_ = static_cast(0); + EmbeddedProto::uint32 timer_period_ = 0U; + EmbeddedProto::uint32 timer_remaining_ = 0U; + +}; + +class Ping final: public ::EmbeddedProto::MessageInterface +{ + public: + Ping() = default; + Ping(const Ping& rhs ) + { + set_ping_ack_id(rhs.get_ping_ack_id()); + set_ping_response_sequence_num(rhs.get_ping_response_sequence_num()); + set_sys_state_response_required(rhs.get_sys_state_response_required()); + } + + Ping(const Ping&& rhs ) noexcept + { + set_ping_ack_id(rhs.get_ping_ack_id()); + set_ping_response_sequence_num(rhs.get_ping_response_sequence_num()); + set_sys_state_response_required(rhs.get_sys_state_response_required()); + } + + ~Ping() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + PING_ACK_ID = 1, + PING_RESPONSE_SEQUENCE_NUM = 2, + SYS_STATE_RESPONSE_REQUIRED = 3 + }; + + Ping& operator=(const Ping& rhs) + { + set_ping_ack_id(rhs.get_ping_ack_id()); + set_ping_response_sequence_num(rhs.get_ping_response_sequence_num()); + set_sys_state_response_required(rhs.get_sys_state_response_required()); + return *this; + } + + Ping& operator=(const Ping&& rhs) noexcept + { + set_ping_ack_id(rhs.get_ping_ack_id()); + set_ping_response_sequence_num(rhs.get_ping_response_sequence_num()); + set_sys_state_response_required(rhs.get_sys_state_response_required()); + return *this; + } + + static constexpr char const* PING_ACK_ID_NAME = "ping_ack_id"; + inline void clear_ping_ack_id() { ping_ack_id_.clear(); } + inline void set_ping_ack_id(const uint32_t& value) { ping_ack_id_ = value; } + inline void set_ping_ack_id(const uint32_t&& value) { ping_ack_id_ = value; } + inline uint32_t& mutable_ping_ack_id() { return ping_ack_id_.get(); } + inline const uint32_t& get_ping_ack_id() const { return ping_ack_id_.get(); } + inline uint32_t ping_ack_id() const { return ping_ack_id_.get(); } + + static constexpr char const* PING_RESPONSE_SEQUENCE_NUM_NAME = "ping_response_sequence_num"; + inline void clear_ping_response_sequence_num() { ping_response_sequence_num_.clear(); } + inline void set_ping_response_sequence_num(const uint32_t& value) { ping_response_sequence_num_ = value; } + inline void set_ping_response_sequence_num(const uint32_t&& value) { ping_response_sequence_num_ = value; } + inline uint32_t& mutable_ping_response_sequence_num() { return ping_response_sequence_num_.get(); } + inline const uint32_t& get_ping_response_sequence_num() const { return ping_response_sequence_num_.get(); } + inline uint32_t ping_response_sequence_num() const { return ping_response_sequence_num_.get(); } + + static constexpr char const* SYS_STATE_RESPONSE_REQUIRED_NAME = "sys_state_response_required"; + inline void clear_sys_state_response_required() { sys_state_response_required_.clear(); } + inline void set_sys_state_response_required(const bool& value) { sys_state_response_required_ = value; } + inline void set_sys_state_response_required(const bool&& value) { sys_state_response_required_ = value; } + inline bool& mutable_sys_state_response_required() { return sys_state_response_required_.get(); } + inline const bool& get_sys_state_response_required() const { return sys_state_response_required_.get(); } + inline bool sys_state_response_required() const { return sys_state_response_required_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != ping_ack_id_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ping_ack_id_.serialize_with_id(static_cast(FieldNumber::PING_ACK_ID), buffer, false); + } + + if((0U != ping_response_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ping_response_sequence_num_.serialize_with_id(static_cast(FieldNumber::PING_RESPONSE_SEQUENCE_NUM), buffer, false); + } + + if((false != sys_state_response_required_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sys_state_response_required_.serialize_with_id(static_cast(FieldNumber::SYS_STATE_RESPONSE_REQUIRED), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::PING_ACK_ID: + return_value = ping_ack_id_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PING_RESPONSE_SEQUENCE_NUM: + return_value = ping_response_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SYS_STATE_RESPONSE_REQUIRED: + return_value = sys_state_response_required_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_ping_ack_id(); + clear_ping_response_sequence_num(); + clear_sys_state_response_required(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::PING_ACK_ID: + name = PING_ACK_ID_NAME; + break; + case FieldNumber::PING_RESPONSE_SEQUENCE_NUM: + name = PING_RESPONSE_SEQUENCE_NUM_NAME; + break; + case FieldNumber::SYS_STATE_RESPONSE_REQUIRED: + name = SYS_STATE_RESPONSE_REQUIRED_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = ping_ack_id_.to_string(left_chars, indent_level + 2, PING_ACK_ID_NAME, true); + left_chars = ping_response_sequence_num_.to_string(left_chars, indent_level + 2, PING_RESPONSE_SEQUENCE_NUM_NAME, false); + left_chars = sys_state_response_required_.to_string(left_chars, indent_level + 2, SYS_STATE_RESPONSE_REQUIRED_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 ping_ack_id_ = 0U; + EmbeddedProto::uint32 ping_response_sequence_num_ = 0U; + EmbeddedProto::boolean sys_state_response_required_ = false; + +}; + +class SystemControl final: public ::EmbeddedProto::MessageInterface +{ + public: + SystemControl() = default; + SystemControl(const SystemControl& rhs ) + { + set_sys_cmd(rhs.get_sys_cmd()); + set_cmd_param(rhs.get_cmd_param()); + } + + SystemControl(const SystemControl&& rhs ) noexcept + { + set_sys_cmd(rhs.get_sys_cmd()); + set_cmd_param(rhs.get_cmd_param()); + } + + ~SystemControl() override = default; + + enum class Command : uint32_t + { + SYS_INVALID = 0, + SYS_RESET = 1, + SYS_FLASH_ERASE = 2, + SYS_LOG_PERIOD_CHANGE = 3, + HEARTBEAT_ENABLE = 4, + HEARTBEAT_DISABLE = 5, + SYS_FLASH_LOG_ENABLE = 6, + SYS_FLASH_LOG_DISABLE = 7, + SYS_CRITICAL_FLASH_FULL_ERASE = 8 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SYS_CMD = 1, + CMD_PARAM = 2 + }; + + SystemControl& operator=(const SystemControl& rhs) + { + set_sys_cmd(rhs.get_sys_cmd()); + set_cmd_param(rhs.get_cmd_param()); + return *this; + } + + SystemControl& operator=(const SystemControl&& rhs) noexcept + { + set_sys_cmd(rhs.get_sys_cmd()); + set_cmd_param(rhs.get_cmd_param()); + return *this; + } + + static constexpr char const* SYS_CMD_NAME = "sys_cmd"; + inline void clear_sys_cmd() { sys_cmd_.clear(); } + inline void set_sys_cmd(const Command& value) { sys_cmd_ = value; } + inline void set_sys_cmd(const Command&& value) { sys_cmd_ = value; } + inline const Command& get_sys_cmd() const { return sys_cmd_.get(); } + inline Command sys_cmd() const { return sys_cmd_.get(); } + + static constexpr char const* CMD_PARAM_NAME = "cmd_param"; + inline void clear_cmd_param() { cmd_param_.clear(); } + inline void set_cmd_param(const uint32_t& value) { cmd_param_ = value; } + inline void set_cmd_param(const uint32_t&& value) { cmd_param_ = value; } + inline uint32_t& mutable_cmd_param() { return cmd_param_.get(); } + inline const uint32_t& get_cmd_param() const { return cmd_param_.get(); } + inline uint32_t cmd_param() const { return cmd_param_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != sys_cmd_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sys_cmd_.serialize_with_id(static_cast(FieldNumber::SYS_CMD), buffer, false); + } + + if((0U != cmd_param_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = cmd_param_.serialize_with_id(static_cast(FieldNumber::CMD_PARAM), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SYS_CMD: + return_value = sys_cmd_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::CMD_PARAM: + return_value = cmd_param_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_sys_cmd(); + clear_cmd_param(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SYS_CMD: + name = SYS_CMD_NAME; + break; + case FieldNumber::CMD_PARAM: + name = CMD_PARAM_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = sys_cmd_.to_string(left_chars, indent_level + 2, SYS_CMD_NAME, true); + left_chars = cmd_param_.to_string(left_chars, indent_level + 2, CMD_PARAM_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration sys_cmd_ = static_cast(0); + EmbeddedProto::uint32 cmd_param_ = 0U; + +}; + +class SystemState final: public ::EmbeddedProto::MessageInterface +{ + public: + SystemState() = default; + SystemState(const SystemState& rhs ) + { + set_sys_state(rhs.get_sys_state()); + if(rhs.has_rocket_state()) + { + set_rocket_state(rhs.get_rocket_state()); + } + else + { + clear_rocket_state(); + } + + } + + SystemState(const SystemState&& rhs ) noexcept + { + set_sys_state(rhs.get_sys_state()); + if(rhs.has_rocket_state()) + { + set_rocket_state(rhs.get_rocket_state()); + } + else + { + clear_rocket_state(); + } + + } + + ~SystemState() override = default; + + enum class State : uint32_t + { + SYS_INVALID = 0, + SYS_BOOTUP_COMPLETE = 1, + SYS_ASSERT_FAILURE_RESET = 2, + SYS_UNCAUGHT_RESET = 3, + SYS_NORMAL_OPERATION = 4, + SYS_HEARTBEAT_LOSS_HALF_WARNING = 5, + SYS_HEARTBEAT_LOST_ABORTING = 6 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SYS_STATE = 1, + ROCKET_STATE = 2 + }; + + SystemState& operator=(const SystemState& rhs) + { + set_sys_state(rhs.get_sys_state()); + if(rhs.has_rocket_state()) + { + set_rocket_state(rhs.get_rocket_state()); + } + else + { + clear_rocket_state(); + } + + return *this; + } + + SystemState& operator=(const SystemState&& rhs) noexcept + { + set_sys_state(rhs.get_sys_state()); + if(rhs.has_rocket_state()) + { + set_rocket_state(rhs.get_rocket_state()); + } + else + { + clear_rocket_state(); + } + + return *this; + } + + static constexpr char const* SYS_STATE_NAME = "sys_state"; + inline void clear_sys_state() { sys_state_.clear(); } + inline void set_sys_state(const State& value) { sys_state_ = value; } + inline void set_sys_state(const State&& value) { sys_state_ = value; } + inline const State& get_sys_state() const { return sys_state_.get(); } + inline State sys_state() const { return sys_state_.get(); } + + static constexpr char const* ROCKET_STATE_NAME = "rocket_state"; + inline bool has_rocket_state() const + { + return 0 != (presence::mask(presence::fields::ROCKET_STATE) & presence_[presence::index(presence::fields::ROCKET_STATE)]); + } + inline void clear_rocket_state() + { + presence_[presence::index(presence::fields::ROCKET_STATE)] &= ~(presence::mask(presence::fields::ROCKET_STATE)); + rocket_state_.clear(); + } + inline void set_rocket_state(const RocketState& value) + { + presence_[presence::index(presence::fields::ROCKET_STATE)] |= presence::mask(presence::fields::ROCKET_STATE); + rocket_state_ = value; + } + inline void set_rocket_state(const RocketState&& value) + { + presence_[presence::index(presence::fields::ROCKET_STATE)] |= presence::mask(presence::fields::ROCKET_STATE); + rocket_state_ = value; + } + inline const RocketState& get_rocket_state() const { return rocket_state_.get(); } + inline RocketState rocket_state() const { return rocket_state_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != sys_state_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sys_state_.serialize_with_id(static_cast(FieldNumber::SYS_STATE), buffer, false); + } + + if(has_rocket_state() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = rocket_state_.serialize_with_id(static_cast(FieldNumber::ROCKET_STATE), buffer, true); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SYS_STATE: + return_value = sys_state_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ROCKET_STATE: + presence_[presence::index(presence::fields::ROCKET_STATE)] |= presence::mask(presence::fields::ROCKET_STATE); + return_value = rocket_state_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_sys_state(); + clear_rocket_state(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SYS_STATE: + name = SYS_STATE_NAME; + break; + case FieldNumber::ROCKET_STATE: + name = ROCKET_STATE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = sys_state_.to_string(left_chars, indent_level + 2, SYS_STATE_NAME, true); + left_chars = rocket_state_.to_string(left_chars, indent_level + 2, ROCKET_STATE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + // Define constants for tracking the presence of fields. + // Use a struct to scope the variables from user fields as namespaces are not allowed within classes. + struct presence + { + // An enumeration with all the fields for which presence has to be tracked. + enum class fields : uint32_t + { + ROCKET_STATE + }; + + // The number of fields for which presence has to be tracked. + static constexpr uint32_t N_FIELDS = 1; + + // Which type are we using to track presence. + using TYPE = uint32_t; + + // How many bits are there in the presence type. + static constexpr uint32_t N_BITS = std::numeric_limits::digits; + + // How many variables of TYPE do we need to bit mask all presence fields. + static constexpr uint32_t SIZE = (N_FIELDS / N_BITS) + ((N_FIELDS % N_BITS) > 0 ? 1 : 0); + + // Obtain the index of a given field in the presence array. + static constexpr uint32_t index(const fields& field) { return static_cast(field) / N_BITS; } + + // Obtain the bit mask for the given field assuming we are at the correct index in the presence array. + static constexpr TYPE mask(const fields& field) + { + return static_cast(0x01) << (static_cast(field) % N_BITS); + } + }; + + // Create an array in which the presence flags are stored. + typename presence::TYPE presence_[presence::SIZE] = {0}; + + EmbeddedProto::enumeration sys_state_ = static_cast(0); + EmbeddedProto::enumeration rocket_state_ = static_cast(0); + +}; + +class ControlMessage final: public ::EmbeddedProto::MessageInterface +{ + public: + ControlMessage() = default; + ControlMessage(const ControlMessage& rhs ) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::ACK: + set_ack(rhs.get_ack()); + break; + + case FieldNumber::NACK: + set_nack(rhs.get_nack()); + break; + + case FieldNumber::PING: + set_ping(rhs.get_ping()); + break; + + case FieldNumber::HB: + set_hb(rhs.get_hb()); + break; + + case FieldNumber::SYS_STATE: + set_sys_state(rhs.get_sys_state()); + break; + + case FieldNumber::SYS_CTRL: + set_sys_ctrl(rhs.get_sys_ctrl()); + break; + + case FieldNumber::HB_STATE: + set_hb_state(rhs.get_hb_state()); + break; + + case FieldNumber::FAST_LOG: + set_fast_log(rhs.get_fast_log()); + break; + + default: + break; + } + + } + + ControlMessage(const ControlMessage&& rhs ) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::ACK: + set_ack(rhs.get_ack()); + break; + + case FieldNumber::NACK: + set_nack(rhs.get_nack()); + break; + + case FieldNumber::PING: + set_ping(rhs.get_ping()); + break; + + case FieldNumber::HB: + set_hb(rhs.get_hb()); + break; + + case FieldNumber::SYS_STATE: + set_sys_state(rhs.get_sys_state()); + break; + + case FieldNumber::SYS_CTRL: + set_sys_ctrl(rhs.get_sys_ctrl()); + break; + + case FieldNumber::HB_STATE: + set_hb_state(rhs.get_hb_state()); + break; + + case FieldNumber::FAST_LOG: + set_fast_log(rhs.get_fast_log()); + break; + + default: + break; + } + + } + + ~ControlMessage() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SOURCE = 1, + TARGET = 2, + SOURCE_SEQUENCE_NUM = 4, + ACK = 5, + NACK = 6, + PING = 7, + HB = 8, + SYS_STATE = 9, + SYS_CTRL = 10, + HB_STATE = 11, + FAST_LOG = 12 + }; + + ControlMessage& operator=(const ControlMessage& rhs) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::ACK: + set_ack(rhs.get_ack()); + break; + + case FieldNumber::NACK: + set_nack(rhs.get_nack()); + break; + + case FieldNumber::PING: + set_ping(rhs.get_ping()); + break; + + case FieldNumber::HB: + set_hb(rhs.get_hb()); + break; + + case FieldNumber::SYS_STATE: + set_sys_state(rhs.get_sys_state()); + break; + + case FieldNumber::SYS_CTRL: + set_sys_ctrl(rhs.get_sys_ctrl()); + break; + + case FieldNumber::HB_STATE: + set_hb_state(rhs.get_hb_state()); + break; + + case FieldNumber::FAST_LOG: + set_fast_log(rhs.get_fast_log()); + break; + + default: + break; + } + + return *this; + } + + ControlMessage& operator=(const ControlMessage&& rhs) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + set_source_sequence_num(rhs.get_source_sequence_num()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::ACK: + set_ack(rhs.get_ack()); + break; + + case FieldNumber::NACK: + set_nack(rhs.get_nack()); + break; + + case FieldNumber::PING: + set_ping(rhs.get_ping()); + break; + + case FieldNumber::HB: + set_hb(rhs.get_hb()); + break; + + case FieldNumber::SYS_STATE: + set_sys_state(rhs.get_sys_state()); + break; + + case FieldNumber::SYS_CTRL: + set_sys_ctrl(rhs.get_sys_ctrl()); + break; + + case FieldNumber::HB_STATE: + set_hb_state(rhs.get_hb_state()); + break; + + case FieldNumber::FAST_LOG: + set_fast_log(rhs.get_fast_log()); + break; + + default: + break; + } + + return *this; + } + + static constexpr char const* SOURCE_NAME = "source"; + inline void clear_source() { source_.clear(); } + inline void set_source(const Node& value) { source_ = value; } + inline void set_source(const Node&& value) { source_ = value; } + inline const Node& get_source() const { return source_.get(); } + inline Node source() const { return source_.get(); } + + static constexpr char const* TARGET_NAME = "target"; + inline void clear_target() { target_.clear(); } + inline void set_target(const Node& value) { target_ = value; } + inline void set_target(const Node&& value) { target_ = value; } + inline const Node& get_target() const { return target_.get(); } + inline Node target() const { return target_.get(); } + + static constexpr char const* SOURCE_SEQUENCE_NUM_NAME = "source_sequence_num"; + inline void clear_source_sequence_num() { source_sequence_num_.clear(); } + inline void set_source_sequence_num(const uint32_t& value) { source_sequence_num_ = value; } + inline void set_source_sequence_num(const uint32_t&& value) { source_sequence_num_ = value; } + inline uint32_t& mutable_source_sequence_num() { return source_sequence_num_.get(); } + inline const uint32_t& get_source_sequence_num() const { return source_sequence_num_.get(); } + inline uint32_t source_sequence_num() const { return source_sequence_num_.get(); } + + FieldNumber get_which_message() const { return which_message_; } + + static constexpr char const* ACK_NAME = "ack"; + inline bool has_ack() const + { + return FieldNumber::ACK == which_message_; + } + inline void clear_ack() + { + if(FieldNumber::ACK == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.ack_.~AckNack(); + } + } + inline void set_ack(const AckNack& value) + { + if(FieldNumber::ACK != which_message_) + { + init_message(FieldNumber::ACK); + } + message_.ack_ = value; + } + inline void set_ack(const AckNack&& value) + { + if(FieldNumber::ACK != which_message_) + { + init_message(FieldNumber::ACK); + } + message_.ack_ = value; + } + inline AckNack& mutable_ack() + { + if(FieldNumber::ACK != which_message_) + { + init_message(FieldNumber::ACK); + } + return message_.ack_; + } + inline const AckNack& get_ack() const { return message_.ack_; } + inline const AckNack& ack() const { return message_.ack_; } + + static constexpr char const* NACK_NAME = "nack"; + inline bool has_nack() const + { + return FieldNumber::NACK == which_message_; + } + inline void clear_nack() + { + if(FieldNumber::NACK == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.nack_.~AckNack(); + } + } + inline void set_nack(const AckNack& value) + { + if(FieldNumber::NACK != which_message_) + { + init_message(FieldNumber::NACK); + } + message_.nack_ = value; + } + inline void set_nack(const AckNack&& value) + { + if(FieldNumber::NACK != which_message_) + { + init_message(FieldNumber::NACK); + } + message_.nack_ = value; + } + inline AckNack& mutable_nack() + { + if(FieldNumber::NACK != which_message_) + { + init_message(FieldNumber::NACK); + } + return message_.nack_; + } + inline const AckNack& get_nack() const { return message_.nack_; } + inline const AckNack& nack() const { return message_.nack_; } + + static constexpr char const* PING_NAME = "ping"; + inline bool has_ping() const + { + return FieldNumber::PING == which_message_; + } + inline void clear_ping() + { + if(FieldNumber::PING == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.ping_.~Ping(); + } + } + inline void set_ping(const Ping& value) + { + if(FieldNumber::PING != which_message_) + { + init_message(FieldNumber::PING); + } + message_.ping_ = value; + } + inline void set_ping(const Ping&& value) + { + if(FieldNumber::PING != which_message_) + { + init_message(FieldNumber::PING); + } + message_.ping_ = value; + } + inline Ping& mutable_ping() + { + if(FieldNumber::PING != which_message_) + { + init_message(FieldNumber::PING); + } + return message_.ping_; + } + inline const Ping& get_ping() const { return message_.ping_; } + inline const Ping& ping() const { return message_.ping_; } + + static constexpr char const* HB_NAME = "hb"; + inline bool has_hb() const + { + return FieldNumber::HB == which_message_; + } + inline void clear_hb() + { + if(FieldNumber::HB == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.hb_.~Heartbeat(); + } + } + inline void set_hb(const Heartbeat& value) + { + if(FieldNumber::HB != which_message_) + { + init_message(FieldNumber::HB); + } + message_.hb_ = value; + } + inline void set_hb(const Heartbeat&& value) + { + if(FieldNumber::HB != which_message_) + { + init_message(FieldNumber::HB); + } + message_.hb_ = value; + } + inline Heartbeat& mutable_hb() + { + if(FieldNumber::HB != which_message_) + { + init_message(FieldNumber::HB); + } + return message_.hb_; + } + inline const Heartbeat& get_hb() const { return message_.hb_; } + inline const Heartbeat& hb() const { return message_.hb_; } + + static constexpr char const* SYS_STATE_NAME = "sys_state"; + inline bool has_sys_state() const + { + return FieldNumber::SYS_STATE == which_message_; + } + inline void clear_sys_state() + { + if(FieldNumber::SYS_STATE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.sys_state_.~SystemState(); + } + } + inline void set_sys_state(const SystemState& value) + { + if(FieldNumber::SYS_STATE != which_message_) + { + init_message(FieldNumber::SYS_STATE); + } + message_.sys_state_ = value; + } + inline void set_sys_state(const SystemState&& value) + { + if(FieldNumber::SYS_STATE != which_message_) + { + init_message(FieldNumber::SYS_STATE); + } + message_.sys_state_ = value; + } + inline SystemState& mutable_sys_state() + { + if(FieldNumber::SYS_STATE != which_message_) + { + init_message(FieldNumber::SYS_STATE); + } + return message_.sys_state_; + } + inline const SystemState& get_sys_state() const { return message_.sys_state_; } + inline const SystemState& sys_state() const { return message_.sys_state_; } + + static constexpr char const* SYS_CTRL_NAME = "sys_ctrl"; + inline bool has_sys_ctrl() const + { + return FieldNumber::SYS_CTRL == which_message_; + } + inline void clear_sys_ctrl() + { + if(FieldNumber::SYS_CTRL == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.sys_ctrl_.~SystemControl(); + } + } + inline void set_sys_ctrl(const SystemControl& value) + { + if(FieldNumber::SYS_CTRL != which_message_) + { + init_message(FieldNumber::SYS_CTRL); + } + message_.sys_ctrl_ = value; + } + inline void set_sys_ctrl(const SystemControl&& value) + { + if(FieldNumber::SYS_CTRL != which_message_) + { + init_message(FieldNumber::SYS_CTRL); + } + message_.sys_ctrl_ = value; + } + inline SystemControl& mutable_sys_ctrl() + { + if(FieldNumber::SYS_CTRL != which_message_) + { + init_message(FieldNumber::SYS_CTRL); + } + return message_.sys_ctrl_; + } + inline const SystemControl& get_sys_ctrl() const { return message_.sys_ctrl_; } + inline const SystemControl& sys_ctrl() const { return message_.sys_ctrl_; } + + static constexpr char const* HB_STATE_NAME = "hb_state"; + inline bool has_hb_state() const + { + return FieldNumber::HB_STATE == which_message_; + } + inline void clear_hb_state() + { + if(FieldNumber::HB_STATE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.hb_state_.~HeartbeatState(); + } + } + inline void set_hb_state(const HeartbeatState& value) + { + if(FieldNumber::HB_STATE != which_message_) + { + init_message(FieldNumber::HB_STATE); + } + message_.hb_state_ = value; + } + inline void set_hb_state(const HeartbeatState&& value) + { + if(FieldNumber::HB_STATE != which_message_) + { + init_message(FieldNumber::HB_STATE); + } + message_.hb_state_ = value; + } + inline HeartbeatState& mutable_hb_state() + { + if(FieldNumber::HB_STATE != which_message_) + { + init_message(FieldNumber::HB_STATE); + } + return message_.hb_state_; + } + inline const HeartbeatState& get_hb_state() const { return message_.hb_state_; } + inline const HeartbeatState& hb_state() const { return message_.hb_state_; } + + static constexpr char const* FAST_LOG_NAME = "fast_log"; + inline bool has_fast_log() const + { + return FieldNumber::FAST_LOG == which_message_; + } + inline void clear_fast_log() + { + if(FieldNumber::FAST_LOG == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.fast_log_.~FastLog(); + } + } + inline void set_fast_log(const FastLog& value) + { + if(FieldNumber::FAST_LOG != which_message_) + { + init_message(FieldNumber::FAST_LOG); + } + message_.fast_log_ = value; + } + inline void set_fast_log(const FastLog&& value) + { + if(FieldNumber::FAST_LOG != which_message_) + { + init_message(FieldNumber::FAST_LOG); + } + message_.fast_log_ = value; + } + inline FastLog& mutable_fast_log() + { + if(FieldNumber::FAST_LOG != which_message_) + { + init_message(FieldNumber::FAST_LOG); + } + return message_.fast_log_; + } + inline const FastLog& get_fast_log() const { return message_.fast_log_; } + inline const FastLog& fast_log() const { return message_.fast_log_; } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != source_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_.serialize_with_id(static_cast(FieldNumber::SOURCE), buffer, false); + } + + if((static_cast(0) != target_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = target_.serialize_with_id(static_cast(FieldNumber::TARGET), buffer, false); + } + + if((0U != source_sequence_num_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_sequence_num_.serialize_with_id(static_cast(FieldNumber::SOURCE_SEQUENCE_NUM), buffer, false); + } + + switch(which_message_) + { + case FieldNumber::ACK: + if(has_ack() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.ack_.serialize_with_id(static_cast(FieldNumber::ACK), buffer, true); + } + break; + + case FieldNumber::NACK: + if(has_nack() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.nack_.serialize_with_id(static_cast(FieldNumber::NACK), buffer, true); + } + break; + + case FieldNumber::PING: + if(has_ping() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.ping_.serialize_with_id(static_cast(FieldNumber::PING), buffer, true); + } + break; + + case FieldNumber::HB: + if(has_hb() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.hb_.serialize_with_id(static_cast(FieldNumber::HB), buffer, true); + } + break; + + case FieldNumber::SYS_STATE: + if(has_sys_state() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.sys_state_.serialize_with_id(static_cast(FieldNumber::SYS_STATE), buffer, true); + } + break; + + case FieldNumber::SYS_CTRL: + if(has_sys_ctrl() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.sys_ctrl_.serialize_with_id(static_cast(FieldNumber::SYS_CTRL), buffer, true); + } + break; + + case FieldNumber::HB_STATE: + if(has_hb_state() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.hb_state_.serialize_with_id(static_cast(FieldNumber::HB_STATE), buffer, true); + } + break; + + case FieldNumber::FAST_LOG: + if(has_fast_log() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.fast_log_.serialize_with_id(static_cast(FieldNumber::FAST_LOG), buffer, true); + } + break; + + default: + break; + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SOURCE: + return_value = source_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TARGET: + return_value = target_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOURCE_SEQUENCE_NUM: + return_value = source_sequence_num_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACK: + case FieldNumber::NACK: + case FieldNumber::PING: + case FieldNumber::HB: + case FieldNumber::SYS_STATE: + case FieldNumber::SYS_CTRL: + case FieldNumber::HB_STATE: + case FieldNumber::FAST_LOG: + return_value = deserialize_message(id_tag, buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_source(); + clear_target(); + clear_source_sequence_num(); + clear_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SOURCE: + name = SOURCE_NAME; + break; + case FieldNumber::TARGET: + name = TARGET_NAME; + break; + case FieldNumber::SOURCE_SEQUENCE_NUM: + name = SOURCE_SEQUENCE_NUM_NAME; + break; + case FieldNumber::ACK: + name = ACK_NAME; + break; + case FieldNumber::NACK: + name = NACK_NAME; + break; + case FieldNumber::PING: + name = PING_NAME; + break; + case FieldNumber::HB: + name = HB_NAME; + break; + case FieldNumber::SYS_STATE: + name = SYS_STATE_NAME; + break; + case FieldNumber::SYS_CTRL: + name = SYS_CTRL_NAME; + break; + case FieldNumber::HB_STATE: + name = HB_STATE_NAME; + break; + case FieldNumber::FAST_LOG: + name = FAST_LOG_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = source_.to_string(left_chars, indent_level + 2, SOURCE_NAME, true); + left_chars = target_.to_string(left_chars, indent_level + 2, TARGET_NAME, false); + left_chars = source_sequence_num_.to_string(left_chars, indent_level + 2, SOURCE_SEQUENCE_NUM_NAME, false); + left_chars = to_string_message(left_chars, indent_level + 2, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration source_ = static_cast(0); + EmbeddedProto::enumeration target_ = static_cast(0); + EmbeddedProto::uint32 source_sequence_num_ = 0U; + + FieldNumber which_message_ = FieldNumber::NOT_SET; + union message + { + message() {} + ~message() {} + AckNack ack_; + AckNack nack_; + Ping ping_; + Heartbeat hb_; + SystemState sys_state_; + SystemControl sys_ctrl_; + HeartbeatState hb_state_; + FastLog fast_log_; + }; + message message_; + + void init_message(const FieldNumber field_id) + { + if(FieldNumber::NOT_SET != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + // C++11 unions only support nontrivial members when you explicitly call the placement new statement. + switch(field_id) + { + case FieldNumber::ACK: + new(&message_.ack_) AckNack; + break; + + case FieldNumber::NACK: + new(&message_.nack_) AckNack; + break; + + case FieldNumber::PING: + new(&message_.ping_) Ping; + break; + + case FieldNumber::HB: + new(&message_.hb_) Heartbeat; + break; + + case FieldNumber::SYS_STATE: + new(&message_.sys_state_) SystemState; + break; + + case FieldNumber::SYS_CTRL: + new(&message_.sys_ctrl_) SystemControl; + break; + + case FieldNumber::HB_STATE: + new(&message_.hb_state_) HeartbeatState; + break; + + case FieldNumber::FAST_LOG: + new(&message_.fast_log_) FastLog; + break; + + default: + break; + } + + which_message_ = field_id; + } + + void clear_message() + { + switch(which_message_) + { + case FieldNumber::ACK: + ::EmbeddedProto::destroy_at(&message_.ack_); + break; + case FieldNumber::NACK: + ::EmbeddedProto::destroy_at(&message_.nack_); + break; + case FieldNumber::PING: + ::EmbeddedProto::destroy_at(&message_.ping_); + break; + case FieldNumber::HB: + ::EmbeddedProto::destroy_at(&message_.hb_); + break; + case FieldNumber::SYS_STATE: + ::EmbeddedProto::destroy_at(&message_.sys_state_); + break; + case FieldNumber::SYS_CTRL: + ::EmbeddedProto::destroy_at(&message_.sys_ctrl_); + break; + case FieldNumber::HB_STATE: + ::EmbeddedProto::destroy_at(&message_.hb_state_); + break; + case FieldNumber::FAST_LOG: + ::EmbeddedProto::destroy_at(&message_.fast_log_); + break; + default: + break; + } + which_message_ = FieldNumber::NOT_SET; + } + + ::EmbeddedProto::Error deserialize_message(const FieldNumber field_id, + ::EmbeddedProto::ReadBufferInterface& buffer, + const ::EmbeddedProto::WireFormatter::WireType wire_type) + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(field_id != which_message_) + { + init_message(field_id); + } + + switch(which_message_) + { + case FieldNumber::ACK: + return_value = message_.ack_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::NACK: + return_value = message_.nack_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PING: + return_value = message_.ping_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::HB: + return_value = message_.hb_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::SYS_STATE: + return_value = message_.sys_state_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::SYS_CTRL: + return_value = message_.sys_ctrl_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::HB_STATE: + return_value = message_.hb_state_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::FAST_LOG: + return_value = message_.fast_log_.deserialize_check_type(buffer, wire_type); + break; + default: + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS != return_value) + { + clear_message(); + } + return return_value; + } + +#ifdef MSG_TO_STRING + ::EmbeddedProto::string_view to_string_message(::EmbeddedProto::string_view& str, const uint32_t indent_level, const bool first_field) const + { + ::EmbeddedProto::string_view left_chars = str; + + switch(which_message_) + { + case FieldNumber::ACK: + left_chars = message_.ack_.to_string(left_chars, indent_level, ACK_NAME, first_field); + break; + case FieldNumber::NACK: + left_chars = message_.nack_.to_string(left_chars, indent_level, NACK_NAME, first_field); + break; + case FieldNumber::PING: + left_chars = message_.ping_.to_string(left_chars, indent_level, PING_NAME, first_field); + break; + case FieldNumber::HB: + left_chars = message_.hb_.to_string(left_chars, indent_level, HB_NAME, first_field); + break; + case FieldNumber::SYS_STATE: + left_chars = message_.sys_state_.to_string(left_chars, indent_level, SYS_STATE_NAME, first_field); + break; + case FieldNumber::SYS_CTRL: + left_chars = message_.sys_ctrl_.to_string(left_chars, indent_level, SYS_CTRL_NAME, first_field); + break; + case FieldNumber::HB_STATE: + left_chars = message_.hb_state_.to_string(left_chars, indent_level, HB_STATE_NAME, first_field); + break; + case FieldNumber::FAST_LOG: + left_chars = message_.fast_log_.to_string(left_chars, indent_level, FAST_LOG_NAME, first_field); + break; + default: + break; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING +}; + +} // End of namespace Proto +#endif // CONTROLMESSAGE_H \ No newline at end of file diff --git a/SoarProto/_C++/CoreProto.h b/SoarProto/_C++/CoreProto.h new file mode 100644 index 0000000..f3fdb5b --- /dev/null +++ b/SoarProto/_C++/CoreProto.h @@ -0,0 +1,54 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: CoreProto.proto + */ + +// This file is generated. Please do not edit! +#ifndef COREPROTO_H +#define COREPROTO_H + +#include +// Include external proto definitions + +namespace Proto { + +enum class Node : uint32_t +{ + NODE_INVALID = 0, + NODE_UNKNOWN = 1, + NODE_ANY = 2, + NODE_RCU = 3, + NODE_DMB = 4, + NODE_PBB = 5, + NODE_SOB = 6 +}; + +enum class MessageID : uint32_t +{ + MSG_INVALID = 0, + MSG_UNKNOWN = 1, + MSG_CONTROL = 2, + MSG_COMMAND = 3, + MSG_TELEMETRY = 4, + MSG_MAX_INVALID = 5 +}; + +enum class RocketState : uint32_t +{ + DMB_INVALID = 0, + RS_PRELAUNCH = 1, + RS_FILL = 2, + RS_ARM = 3, + RS_IGNITION = 4, + RS_LAUNCH = 5, + RS_BURN = 6, + RS_COAST = 7, + RS_DESCENT = 8, + RS_RECOVERY = 9, + RS_ABORT = 10, + RS_TEST = 11, + RS_NONE = 12 +}; + +} // End of namespace Proto +#endif // COREPROTO_H \ No newline at end of file diff --git a/SoarProto/_C++/SensorData.hpp b/SoarProto/_C++/SensorData.hpp new file mode 100644 index 0000000..d77b53f --- /dev/null +++ b/SoarProto/_C++/SensorData.hpp @@ -0,0 +1,2519 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: SensorData.proto + */ + +// This file is generated. Please do not edit! +#ifndef SENSORDATA_H +#define SENSORDATA_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Include external proto definitions + +namespace Proto { + +class SensorLoggingRate final: public ::EmbeddedProto::MessageInterface +{ + public: + SensorLoggingRate() = default; + SensorLoggingRate(const SensorLoggingRate& rhs ) + { + set_changeLoggingRate(rhs.get_changeLoggingRate()); + set_newSensorLoggingRate(rhs.get_newSensorLoggingRate()); + } + + SensorLoggingRate(const SensorLoggingRate&& rhs ) noexcept + { + set_changeLoggingRate(rhs.get_changeLoggingRate()); + set_newSensorLoggingRate(rhs.get_newSensorLoggingRate()); + } + + ~SensorLoggingRate() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + CHANGELOGGINGRATE = 1, + NEWSENSORLOGGINGRATE = 2 + }; + + SensorLoggingRate& operator=(const SensorLoggingRate& rhs) + { + set_changeLoggingRate(rhs.get_changeLoggingRate()); + set_newSensorLoggingRate(rhs.get_newSensorLoggingRate()); + return *this; + } + + SensorLoggingRate& operator=(const SensorLoggingRate&& rhs) noexcept + { + set_changeLoggingRate(rhs.get_changeLoggingRate()); + set_newSensorLoggingRate(rhs.get_newSensorLoggingRate()); + return *this; + } + + static constexpr char const* CHANGELOGGINGRATE_NAME = "changeLoggingRate"; + inline void clear_changeLoggingRate() { changeLoggingRate_.clear(); } + inline void set_changeLoggingRate(const bool& value) { changeLoggingRate_ = value; } + inline void set_changeLoggingRate(const bool&& value) { changeLoggingRate_ = value; } + inline bool& mutable_changeLoggingRate() { return changeLoggingRate_.get(); } + inline const bool& get_changeLoggingRate() const { return changeLoggingRate_.get(); } + inline bool changeLoggingRate() const { return changeLoggingRate_.get(); } + + static constexpr char const* NEWSENSORLOGGINGRATE_NAME = "newSensorLoggingRate"; + inline void clear_newSensorLoggingRate() { newSensorLoggingRate_.clear(); } + inline void set_newSensorLoggingRate(const uint32_t& value) { newSensorLoggingRate_ = value; } + inline void set_newSensorLoggingRate(const uint32_t&& value) { newSensorLoggingRate_ = value; } + inline uint32_t& mutable_newSensorLoggingRate() { return newSensorLoggingRate_.get(); } + inline const uint32_t& get_newSensorLoggingRate() const { return newSensorLoggingRate_.get(); } + inline uint32_t newSensorLoggingRate() const { return newSensorLoggingRate_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((false != changeLoggingRate_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = changeLoggingRate_.serialize_with_id(static_cast(FieldNumber::CHANGELOGGINGRATE), buffer, false); + } + + if((0U != newSensorLoggingRate_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = newSensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::NEWSENSORLOGGINGRATE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::CHANGELOGGINGRATE: + return_value = changeLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NEWSENSORLOGGINGRATE: + return_value = newSensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_changeLoggingRate(); + clear_newSensorLoggingRate(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::CHANGELOGGINGRATE: + name = CHANGELOGGINGRATE_NAME; + break; + case FieldNumber::NEWSENSORLOGGINGRATE: + name = NEWSENSORLOGGINGRATE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = changeLoggingRate_.to_string(left_chars, indent_level + 2, CHANGELOGGINGRATE_NAME, true); + left_chars = newSensorLoggingRate_.to_string(left_chars, indent_level + 2, NEWSENSORLOGGINGRATE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::boolean changeLoggingRate_ = false; + EmbeddedProto::uint32 newSensorLoggingRate_ = 0U; + +}; + +class Accelerometer final: public ::EmbeddedProto::MessageInterface +{ + public: + Accelerometer() = default; + Accelerometer(const Accelerometer& rhs ) + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + Accelerometer(const Accelerometer&& rhs ) noexcept + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + ~Accelerometer() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + ACCEL_X = 1, + ACCEL_Y = 2, + ACCEL_Z = 3, + SENSORLOGGINGRATE = 4, + LOGGINGIDX = 5 + }; + + Accelerometer& operator=(const Accelerometer& rhs) + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + Accelerometer& operator=(const Accelerometer&& rhs) noexcept + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + static constexpr char const* ACCEL_X_NAME = "accel_x"; + inline void clear_accel_x() { accel_x_.clear(); } + inline void set_accel_x(const int32_t& value) { accel_x_ = value; } + inline void set_accel_x(const int32_t&& value) { accel_x_ = value; } + inline int32_t& mutable_accel_x() { return accel_x_.get(); } + inline const int32_t& get_accel_x() const { return accel_x_.get(); } + inline int32_t accel_x() const { return accel_x_.get(); } + + static constexpr char const* ACCEL_Y_NAME = "accel_y"; + inline void clear_accel_y() { accel_y_.clear(); } + inline void set_accel_y(const int32_t& value) { accel_y_ = value; } + inline void set_accel_y(const int32_t&& value) { accel_y_ = value; } + inline int32_t& mutable_accel_y() { return accel_y_.get(); } + inline const int32_t& get_accel_y() const { return accel_y_.get(); } + inline int32_t accel_y() const { return accel_y_.get(); } + + static constexpr char const* ACCEL_Z_NAME = "accel_z"; + inline void clear_accel_z() { accel_z_.clear(); } + inline void set_accel_z(const int32_t& value) { accel_z_ = value; } + inline void set_accel_z(const int32_t&& value) { accel_z_ = value; } + inline int32_t& mutable_accel_z() { return accel_z_.get(); } + inline const int32_t& get_accel_z() const { return accel_z_.get(); } + inline int32_t accel_z() const { return accel_z_.get(); } + + static constexpr char const* SENSORLOGGINGRATE_NAME = "sensorLoggingRate"; + inline void clear_sensorLoggingRate() { sensorLoggingRate_.clear(); } + inline void set_sensorLoggingRate(const SensorLoggingRate& value) { sensorLoggingRate_ = value; } + inline void set_sensorLoggingRate(const SensorLoggingRate&& value) { sensorLoggingRate_ = value; } + inline SensorLoggingRate& mutable_sensorLoggingRate() { return sensorLoggingRate_; } + inline const SensorLoggingRate& get_sensorLoggingRate() const { return sensorLoggingRate_; } + inline const SensorLoggingRate& sensorLoggingRate() const { return sensorLoggingRate_; } + + static constexpr char const* LOGGINGIDX_NAME = "LoggingIdx"; + inline void clear_LoggingIdx() { LoggingIdx_.clear(); } + inline void set_LoggingIdx(const int32_t& value) { LoggingIdx_ = value; } + inline void set_LoggingIdx(const int32_t&& value) { LoggingIdx_ = value; } + inline int32_t& mutable_LoggingIdx() { return LoggingIdx_.get(); } + inline const int32_t& get_LoggingIdx() const { return LoggingIdx_.get(); } + inline int32_t LoggingIdx() const { return LoggingIdx_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != accel_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_x_.serialize_with_id(static_cast(FieldNumber::ACCEL_X), buffer, false); + } + + if((0 != accel_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_y_.serialize_with_id(static_cast(FieldNumber::ACCEL_Y), buffer, false); + } + + if((0 != accel_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_z_.serialize_with_id(static_cast(FieldNumber::ACCEL_Z), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = sensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::SENSORLOGGINGRATE), buffer, false); + } + + if((0 != LoggingIdx_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = LoggingIdx_.serialize_with_id(static_cast(FieldNumber::LOGGINGIDX), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::ACCEL_X: + return_value = accel_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACCEL_Y: + return_value = accel_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACCEL_Z: + return_value = accel_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SENSORLOGGINGRATE: + return_value = sensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGINGIDX: + return_value = LoggingIdx_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_accel_x(); + clear_accel_y(); + clear_accel_z(); + clear_sensorLoggingRate(); + clear_LoggingIdx(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::ACCEL_X: + name = ACCEL_X_NAME; + break; + case FieldNumber::ACCEL_Y: + name = ACCEL_Y_NAME; + break; + case FieldNumber::ACCEL_Z: + name = ACCEL_Z_NAME; + break; + case FieldNumber::SENSORLOGGINGRATE: + name = SENSORLOGGINGRATE_NAME; + break; + case FieldNumber::LOGGINGIDX: + name = LOGGINGIDX_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = accel_x_.to_string(left_chars, indent_level + 2, ACCEL_X_NAME, true); + left_chars = accel_y_.to_string(left_chars, indent_level + 2, ACCEL_Y_NAME, false); + left_chars = accel_z_.to_string(left_chars, indent_level + 2, ACCEL_Z_NAME, false); + left_chars = sensorLoggingRate_.to_string(left_chars, indent_level + 2, SENSORLOGGINGRATE_NAME, false); + left_chars = LoggingIdx_.to_string(left_chars, indent_level + 2, LOGGINGIDX_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 accel_x_ = 0; + EmbeddedProto::int32 accel_y_ = 0; + EmbeddedProto::int32 accel_z_ = 0; + SensorLoggingRate sensorLoggingRate_; + EmbeddedProto::int32 LoggingIdx_ = 0; + +}; + +class Barometer final: public ::EmbeddedProto::MessageInterface +{ + public: + Barometer() = default; + Barometer(const Barometer& rhs ) + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + Barometer(const Barometer&& rhs ) noexcept + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + ~Barometer() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + BARO_PRESSURE = 1, + BARO_TEMPERATURE = 2, + SENSORLOGGINGRATE = 3, + LOGGINGIDX = 4 + }; + + Barometer& operator=(const Barometer& rhs) + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + Barometer& operator=(const Barometer&& rhs) noexcept + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + static constexpr char const* BARO_PRESSURE_NAME = "baro_pressure"; + inline void clear_baro_pressure() { baro_pressure_.clear(); } + inline void set_baro_pressure(const int32_t& value) { baro_pressure_ = value; } + inline void set_baro_pressure(const int32_t&& value) { baro_pressure_ = value; } + inline int32_t& mutable_baro_pressure() { return baro_pressure_.get(); } + inline const int32_t& get_baro_pressure() const { return baro_pressure_.get(); } + inline int32_t baro_pressure() const { return baro_pressure_.get(); } + + static constexpr char const* BARO_TEMPERATURE_NAME = "baro_temperature"; + inline void clear_baro_temperature() { baro_temperature_.clear(); } + inline void set_baro_temperature(const int32_t& value) { baro_temperature_ = value; } + inline void set_baro_temperature(const int32_t&& value) { baro_temperature_ = value; } + inline int32_t& mutable_baro_temperature() { return baro_temperature_.get(); } + inline const int32_t& get_baro_temperature() const { return baro_temperature_.get(); } + inline int32_t baro_temperature() const { return baro_temperature_.get(); } + + static constexpr char const* SENSORLOGGINGRATE_NAME = "sensorLoggingRate"; + inline void clear_sensorLoggingRate() { sensorLoggingRate_.clear(); } + inline void set_sensorLoggingRate(const SensorLoggingRate& value) { sensorLoggingRate_ = value; } + inline void set_sensorLoggingRate(const SensorLoggingRate&& value) { sensorLoggingRate_ = value; } + inline SensorLoggingRate& mutable_sensorLoggingRate() { return sensorLoggingRate_; } + inline const SensorLoggingRate& get_sensorLoggingRate() const { return sensorLoggingRate_; } + inline const SensorLoggingRate& sensorLoggingRate() const { return sensorLoggingRate_; } + + static constexpr char const* LOGGINGIDX_NAME = "LoggingIdx"; + inline void clear_LoggingIdx() { LoggingIdx_.clear(); } + inline void set_LoggingIdx(const int32_t& value) { LoggingIdx_ = value; } + inline void set_LoggingIdx(const int32_t&& value) { LoggingIdx_ = value; } + inline int32_t& mutable_LoggingIdx() { return LoggingIdx_.get(); } + inline const int32_t& get_LoggingIdx() const { return LoggingIdx_.get(); } + inline int32_t LoggingIdx() const { return LoggingIdx_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != baro_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = baro_pressure_.serialize_with_id(static_cast(FieldNumber::BARO_PRESSURE), buffer, false); + } + + if((0 != baro_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = baro_temperature_.serialize_with_id(static_cast(FieldNumber::BARO_TEMPERATURE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = sensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::SENSORLOGGINGRATE), buffer, false); + } + + if((0 != LoggingIdx_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = LoggingIdx_.serialize_with_id(static_cast(FieldNumber::LOGGINGIDX), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::BARO_PRESSURE: + return_value = baro_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::BARO_TEMPERATURE: + return_value = baro_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SENSORLOGGINGRATE: + return_value = sensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGINGIDX: + return_value = LoggingIdx_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_baro_pressure(); + clear_baro_temperature(); + clear_sensorLoggingRate(); + clear_LoggingIdx(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::BARO_PRESSURE: + name = BARO_PRESSURE_NAME; + break; + case FieldNumber::BARO_TEMPERATURE: + name = BARO_TEMPERATURE_NAME; + break; + case FieldNumber::SENSORLOGGINGRATE: + name = SENSORLOGGINGRATE_NAME; + break; + case FieldNumber::LOGGINGIDX: + name = LOGGINGIDX_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = baro_pressure_.to_string(left_chars, indent_level + 2, BARO_PRESSURE_NAME, true); + left_chars = baro_temperature_.to_string(left_chars, indent_level + 2, BARO_TEMPERATURE_NAME, false); + left_chars = sensorLoggingRate_.to_string(left_chars, indent_level + 2, SENSORLOGGINGRATE_NAME, false); + left_chars = LoggingIdx_.to_string(left_chars, indent_level + 2, LOGGINGIDX_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 baro_pressure_ = 0; + EmbeddedProto::int32 baro_temperature_ = 0; + SensorLoggingRate sensorLoggingRate_; + EmbeddedProto::int32 LoggingIdx_ = 0; + +}; + +class Gyroscope final: public ::EmbeddedProto::MessageInterface +{ + public: + Gyroscope() = default; + Gyroscope(const Gyroscope& rhs ) + { + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + Gyroscope(const Gyroscope&& rhs ) noexcept + { + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + ~Gyroscope() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + GYRO_X = 1, + GYRO_Y = 2, + GYRO_Z = 3, + SENSORLOGGINGRATE = 4, + LOGGINGIDX = 5 + }; + + Gyroscope& operator=(const Gyroscope& rhs) + { + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + Gyroscope& operator=(const Gyroscope&& rhs) noexcept + { + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + static constexpr char const* GYRO_X_NAME = "gyro_x"; + inline void clear_gyro_x() { gyro_x_.clear(); } + inline void set_gyro_x(const int32_t& value) { gyro_x_ = value; } + inline void set_gyro_x(const int32_t&& value) { gyro_x_ = value; } + inline int32_t& mutable_gyro_x() { return gyro_x_.get(); } + inline const int32_t& get_gyro_x() const { return gyro_x_.get(); } + inline int32_t gyro_x() const { return gyro_x_.get(); } + + static constexpr char const* GYRO_Y_NAME = "gyro_y"; + inline void clear_gyro_y() { gyro_y_.clear(); } + inline void set_gyro_y(const int32_t& value) { gyro_y_ = value; } + inline void set_gyro_y(const int32_t&& value) { gyro_y_ = value; } + inline int32_t& mutable_gyro_y() { return gyro_y_.get(); } + inline const int32_t& get_gyro_y() const { return gyro_y_.get(); } + inline int32_t gyro_y() const { return gyro_y_.get(); } + + static constexpr char const* GYRO_Z_NAME = "gyro_z"; + inline void clear_gyro_z() { gyro_z_.clear(); } + inline void set_gyro_z(const int32_t& value) { gyro_z_ = value; } + inline void set_gyro_z(const int32_t&& value) { gyro_z_ = value; } + inline int32_t& mutable_gyro_z() { return gyro_z_.get(); } + inline const int32_t& get_gyro_z() const { return gyro_z_.get(); } + inline int32_t gyro_z() const { return gyro_z_.get(); } + + static constexpr char const* SENSORLOGGINGRATE_NAME = "sensorLoggingRate"; + inline void clear_sensorLoggingRate() { sensorLoggingRate_.clear(); } + inline void set_sensorLoggingRate(const SensorLoggingRate& value) { sensorLoggingRate_ = value; } + inline void set_sensorLoggingRate(const SensorLoggingRate&& value) { sensorLoggingRate_ = value; } + inline SensorLoggingRate& mutable_sensorLoggingRate() { return sensorLoggingRate_; } + inline const SensorLoggingRate& get_sensorLoggingRate() const { return sensorLoggingRate_; } + inline const SensorLoggingRate& sensorLoggingRate() const { return sensorLoggingRate_; } + + static constexpr char const* LOGGINGIDX_NAME = "LoggingIdx"; + inline void clear_LoggingIdx() { LoggingIdx_.clear(); } + inline void set_LoggingIdx(const int32_t& value) { LoggingIdx_ = value; } + inline void set_LoggingIdx(const int32_t&& value) { LoggingIdx_ = value; } + inline int32_t& mutable_LoggingIdx() { return LoggingIdx_.get(); } + inline const int32_t& get_LoggingIdx() const { return LoggingIdx_.get(); } + inline int32_t LoggingIdx() const { return LoggingIdx_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != gyro_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_x_.serialize_with_id(static_cast(FieldNumber::GYRO_X), buffer, false); + } + + if((0 != gyro_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_y_.serialize_with_id(static_cast(FieldNumber::GYRO_Y), buffer, false); + } + + if((0 != gyro_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_z_.serialize_with_id(static_cast(FieldNumber::GYRO_Z), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = sensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::SENSORLOGGINGRATE), buffer, false); + } + + if((0 != LoggingIdx_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = LoggingIdx_.serialize_with_id(static_cast(FieldNumber::LOGGINGIDX), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::GYRO_X: + return_value = gyro_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GYRO_Y: + return_value = gyro_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GYRO_Z: + return_value = gyro_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SENSORLOGGINGRATE: + return_value = sensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGINGIDX: + return_value = LoggingIdx_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_gyro_x(); + clear_gyro_y(); + clear_gyro_z(); + clear_sensorLoggingRate(); + clear_LoggingIdx(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::GYRO_X: + name = GYRO_X_NAME; + break; + case FieldNumber::GYRO_Y: + name = GYRO_Y_NAME; + break; + case FieldNumber::GYRO_Z: + name = GYRO_Z_NAME; + break; + case FieldNumber::SENSORLOGGINGRATE: + name = SENSORLOGGINGRATE_NAME; + break; + case FieldNumber::LOGGINGIDX: + name = LOGGINGIDX_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = gyro_x_.to_string(left_chars, indent_level + 2, GYRO_X_NAME, true); + left_chars = gyro_y_.to_string(left_chars, indent_level + 2, GYRO_Y_NAME, false); + left_chars = gyro_z_.to_string(left_chars, indent_level + 2, GYRO_Z_NAME, false); + left_chars = sensorLoggingRate_.to_string(left_chars, indent_level + 2, SENSORLOGGINGRATE_NAME, false); + left_chars = LoggingIdx_.to_string(left_chars, indent_level + 2, LOGGINGIDX_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 gyro_x_ = 0; + EmbeddedProto::int32 gyro_y_ = 0; + EmbeddedProto::int32 gyro_z_ = 0; + SensorLoggingRate sensorLoggingRate_; + EmbeddedProto::int32 LoggingIdx_ = 0; + +}; + +class Magnetometer final: public ::EmbeddedProto::MessageInterface +{ + public: + Magnetometer() = default; + Magnetometer(const Magnetometer& rhs ) + { + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + Magnetometer(const Magnetometer&& rhs ) noexcept + { + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + ~Magnetometer() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + MAG_X = 1, + MAG_Y = 2, + MAG_Z = 3, + SENSORLOGGINGRATE = 4, + LOGGINGIDX = 5 + }; + + Magnetometer& operator=(const Magnetometer& rhs) + { + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + Magnetometer& operator=(const Magnetometer&& rhs) noexcept + { + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + static constexpr char const* MAG_X_NAME = "mag_x"; + inline void clear_mag_x() { mag_x_.clear(); } + inline void set_mag_x(const int32_t& value) { mag_x_ = value; } + inline void set_mag_x(const int32_t&& value) { mag_x_ = value; } + inline int32_t& mutable_mag_x() { return mag_x_.get(); } + inline const int32_t& get_mag_x() const { return mag_x_.get(); } + inline int32_t mag_x() const { return mag_x_.get(); } + + static constexpr char const* MAG_Y_NAME = "mag_y"; + inline void clear_mag_y() { mag_y_.clear(); } + inline void set_mag_y(const int32_t& value) { mag_y_ = value; } + inline void set_mag_y(const int32_t&& value) { mag_y_ = value; } + inline int32_t& mutable_mag_y() { return mag_y_.get(); } + inline const int32_t& get_mag_y() const { return mag_y_.get(); } + inline int32_t mag_y() const { return mag_y_.get(); } + + static constexpr char const* MAG_Z_NAME = "mag_z"; + inline void clear_mag_z() { mag_z_.clear(); } + inline void set_mag_z(const int32_t& value) { mag_z_ = value; } + inline void set_mag_z(const int32_t&& value) { mag_z_ = value; } + inline int32_t& mutable_mag_z() { return mag_z_.get(); } + inline const int32_t& get_mag_z() const { return mag_z_.get(); } + inline int32_t mag_z() const { return mag_z_.get(); } + + static constexpr char const* SENSORLOGGINGRATE_NAME = "sensorLoggingRate"; + inline void clear_sensorLoggingRate() { sensorLoggingRate_.clear(); } + inline void set_sensorLoggingRate(const SensorLoggingRate& value) { sensorLoggingRate_ = value; } + inline void set_sensorLoggingRate(const SensorLoggingRate&& value) { sensorLoggingRate_ = value; } + inline SensorLoggingRate& mutable_sensorLoggingRate() { return sensorLoggingRate_; } + inline const SensorLoggingRate& get_sensorLoggingRate() const { return sensorLoggingRate_; } + inline const SensorLoggingRate& sensorLoggingRate() const { return sensorLoggingRate_; } + + static constexpr char const* LOGGINGIDX_NAME = "LoggingIdx"; + inline void clear_LoggingIdx() { LoggingIdx_.clear(); } + inline void set_LoggingIdx(const int32_t& value) { LoggingIdx_ = value; } + inline void set_LoggingIdx(const int32_t&& value) { LoggingIdx_ = value; } + inline int32_t& mutable_LoggingIdx() { return LoggingIdx_.get(); } + inline const int32_t& get_LoggingIdx() const { return LoggingIdx_.get(); } + inline int32_t LoggingIdx() const { return LoggingIdx_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != mag_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_x_.serialize_with_id(static_cast(FieldNumber::MAG_X), buffer, false); + } + + if((0 != mag_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_y_.serialize_with_id(static_cast(FieldNumber::MAG_Y), buffer, false); + } + + if((0 != mag_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_z_.serialize_with_id(static_cast(FieldNumber::MAG_Z), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = sensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::SENSORLOGGINGRATE), buffer, false); + } + + if((0 != LoggingIdx_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = LoggingIdx_.serialize_with_id(static_cast(FieldNumber::LOGGINGIDX), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::MAG_X: + return_value = mag_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MAG_Y: + return_value = mag_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MAG_Z: + return_value = mag_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SENSORLOGGINGRATE: + return_value = sensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGINGIDX: + return_value = LoggingIdx_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_mag_x(); + clear_mag_y(); + clear_mag_z(); + clear_sensorLoggingRate(); + clear_LoggingIdx(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::MAG_X: + name = MAG_X_NAME; + break; + case FieldNumber::MAG_Y: + name = MAG_Y_NAME; + break; + case FieldNumber::MAG_Z: + name = MAG_Z_NAME; + break; + case FieldNumber::SENSORLOGGINGRATE: + name = SENSORLOGGINGRATE_NAME; + break; + case FieldNumber::LOGGINGIDX: + name = LOGGINGIDX_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = mag_x_.to_string(left_chars, indent_level + 2, MAG_X_NAME, true); + left_chars = mag_y_.to_string(left_chars, indent_level + 2, MAG_Y_NAME, false); + left_chars = mag_z_.to_string(left_chars, indent_level + 2, MAG_Z_NAME, false); + left_chars = sensorLoggingRate_.to_string(left_chars, indent_level + 2, SENSORLOGGINGRATE_NAME, false); + left_chars = LoggingIdx_.to_string(left_chars, indent_level + 2, LOGGINGIDX_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 mag_x_ = 0; + EmbeddedProto::int32 mag_y_ = 0; + EmbeddedProto::int32 mag_z_ = 0; + SensorLoggingRate sensorLoggingRate_; + EmbeddedProto::int32 LoggingIdx_ = 0; + +}; + +class Thermocouple final: public ::EmbeddedProto::MessageInterface +{ + public: + Thermocouple() = default; + Thermocouple(const Thermocouple& rhs ) + { + set_termo_temperature(rhs.get_termo_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + Thermocouple(const Thermocouple&& rhs ) noexcept + { + set_termo_temperature(rhs.get_termo_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + } + + ~Thermocouple() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TERMO_TEMPERATURE = 1, + SENSORLOGGINGRATE = 2, + LOGGINGIDX = 3 + }; + + Thermocouple& operator=(const Thermocouple& rhs) + { + set_termo_temperature(rhs.get_termo_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + Thermocouple& operator=(const Thermocouple&& rhs) noexcept + { + set_termo_temperature(rhs.get_termo_temperature()); + set_sensorLoggingRate(rhs.get_sensorLoggingRate()); + set_LoggingIdx(rhs.get_LoggingIdx()); + return *this; + } + + static constexpr char const* TERMO_TEMPERATURE_NAME = "termo_temperature"; + inline void clear_termo_temperature() { termo_temperature_.clear(); } + inline void set_termo_temperature(const int32_t& value) { termo_temperature_ = value; } + inline void set_termo_temperature(const int32_t&& value) { termo_temperature_ = value; } + inline int32_t& mutable_termo_temperature() { return termo_temperature_.get(); } + inline const int32_t& get_termo_temperature() const { return termo_temperature_.get(); } + inline int32_t termo_temperature() const { return termo_temperature_.get(); } + + static constexpr char const* SENSORLOGGINGRATE_NAME = "sensorLoggingRate"; + inline void clear_sensorLoggingRate() { sensorLoggingRate_.clear(); } + inline void set_sensorLoggingRate(const SensorLoggingRate& value) { sensorLoggingRate_ = value; } + inline void set_sensorLoggingRate(const SensorLoggingRate&& value) { sensorLoggingRate_ = value; } + inline SensorLoggingRate& mutable_sensorLoggingRate() { return sensorLoggingRate_; } + inline const SensorLoggingRate& get_sensorLoggingRate() const { return sensorLoggingRate_; } + inline const SensorLoggingRate& sensorLoggingRate() const { return sensorLoggingRate_; } + + static constexpr char const* LOGGINGIDX_NAME = "LoggingIdx"; + inline void clear_LoggingIdx() { LoggingIdx_.clear(); } + inline void set_LoggingIdx(const int32_t& value) { LoggingIdx_ = value; } + inline void set_LoggingIdx(const int32_t&& value) { LoggingIdx_ = value; } + inline int32_t& mutable_LoggingIdx() { return LoggingIdx_.get(); } + inline const int32_t& get_LoggingIdx() const { return LoggingIdx_.get(); } + inline int32_t LoggingIdx() const { return LoggingIdx_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != termo_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = termo_temperature_.serialize_with_id(static_cast(FieldNumber::TERMO_TEMPERATURE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = sensorLoggingRate_.serialize_with_id(static_cast(FieldNumber::SENSORLOGGINGRATE), buffer, false); + } + + if((0 != LoggingIdx_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = LoggingIdx_.serialize_with_id(static_cast(FieldNumber::LOGGINGIDX), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TERMO_TEMPERATURE: + return_value = termo_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SENSORLOGGINGRATE: + return_value = sensorLoggingRate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGINGIDX: + return_value = LoggingIdx_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_termo_temperature(); + clear_sensorLoggingRate(); + clear_LoggingIdx(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TERMO_TEMPERATURE: + name = TERMO_TEMPERATURE_NAME; + break; + case FieldNumber::SENSORLOGGINGRATE: + name = SENSORLOGGINGRATE_NAME; + break; + case FieldNumber::LOGGINGIDX: + name = LOGGINGIDX_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = termo_temperature_.to_string(left_chars, indent_level + 2, TERMO_TEMPERATURE_NAME, true); + left_chars = sensorLoggingRate_.to_string(left_chars, indent_level + 2, SENSORLOGGINGRATE_NAME, false); + left_chars = LoggingIdx_.to_string(left_chars, indent_level + 2, LOGGINGIDX_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 termo_temperature_ = 0; + SensorLoggingRate sensorLoggingRate_; + EmbeddedProto::int32 LoggingIdx_ = 0; + +}; + +class SensorData final: public ::EmbeddedProto::MessageInterface +{ + public: + SensorData() = default; + SensorData(const SensorData& rhs ) + { + set_timestamp(rhs.get_timestamp()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::BAROMETERMESSAGE: + set_barometerMessage(rhs.get_barometerMessage()); + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + set_accelerometerMessage(rhs.get_accelerometerMessage()); + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + set_magnetometerMessage(rhs.get_magnetometerMessage()); + break; + + case FieldNumber::GYROSCOPERMESSAGE: + set_gyroscoperMessage(rhs.get_gyroscoperMessage()); + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + set_thermocoupleMessage(rhs.get_thermocoupleMessage()); + break; + + default: + break; + } + + } + + SensorData(const SensorData&& rhs ) noexcept + { + set_timestamp(rhs.get_timestamp()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::BAROMETERMESSAGE: + set_barometerMessage(rhs.get_barometerMessage()); + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + set_accelerometerMessage(rhs.get_accelerometerMessage()); + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + set_magnetometerMessage(rhs.get_magnetometerMessage()); + break; + + case FieldNumber::GYROSCOPERMESSAGE: + set_gyroscoperMessage(rhs.get_gyroscoperMessage()); + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + set_thermocoupleMessage(rhs.get_thermocoupleMessage()); + break; + + default: + break; + } + + } + + ~SensorData() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TIMESTAMP = 1, + BAROMETERMESSAGE = 2, + ACCELEROMETERMESSAGE = 3, + MAGNETOMETERMESSAGE = 4, + GYROSCOPERMESSAGE = 5, + THERMOCOUPLEMESSAGE = 6 + }; + + SensorData& operator=(const SensorData& rhs) + { + set_timestamp(rhs.get_timestamp()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::BAROMETERMESSAGE: + set_barometerMessage(rhs.get_barometerMessage()); + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + set_accelerometerMessage(rhs.get_accelerometerMessage()); + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + set_magnetometerMessage(rhs.get_magnetometerMessage()); + break; + + case FieldNumber::GYROSCOPERMESSAGE: + set_gyroscoperMessage(rhs.get_gyroscoperMessage()); + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + set_thermocoupleMessage(rhs.get_thermocoupleMessage()); + break; + + default: + break; + } + + return *this; + } + + SensorData& operator=(const SensorData&& rhs) noexcept + { + set_timestamp(rhs.get_timestamp()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::BAROMETERMESSAGE: + set_barometerMessage(rhs.get_barometerMessage()); + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + set_accelerometerMessage(rhs.get_accelerometerMessage()); + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + set_magnetometerMessage(rhs.get_magnetometerMessage()); + break; + + case FieldNumber::GYROSCOPERMESSAGE: + set_gyroscoperMessage(rhs.get_gyroscoperMessage()); + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + set_thermocoupleMessage(rhs.get_thermocoupleMessage()); + break; + + default: + break; + } + + return *this; + } + + static constexpr char const* TIMESTAMP_NAME = "timestamp"; + inline void clear_timestamp() { timestamp_.clear(); } + inline void set_timestamp(const uint32_t& value) { timestamp_ = value; } + inline void set_timestamp(const uint32_t&& value) { timestamp_ = value; } + inline uint32_t& mutable_timestamp() { return timestamp_.get(); } + inline const uint32_t& get_timestamp() const { return timestamp_.get(); } + inline uint32_t timestamp() const { return timestamp_.get(); } + + FieldNumber get_which_message() const { return which_message_; } + + static constexpr char const* BAROMETERMESSAGE_NAME = "barometerMessage"; + inline bool has_barometerMessage() const + { + return FieldNumber::BAROMETERMESSAGE == which_message_; + } + inline void clear_barometerMessage() + { + if(FieldNumber::BAROMETERMESSAGE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.barometerMessage_.~Barometer(); + } + } + inline void set_barometerMessage(const Barometer& value) + { + if(FieldNumber::BAROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::BAROMETERMESSAGE); + } + message_.barometerMessage_ = value; + } + inline void set_barometerMessage(const Barometer&& value) + { + if(FieldNumber::BAROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::BAROMETERMESSAGE); + } + message_.barometerMessage_ = value; + } + inline Barometer& mutable_barometerMessage() + { + if(FieldNumber::BAROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::BAROMETERMESSAGE); + } + return message_.barometerMessage_; + } + inline const Barometer& get_barometerMessage() const { return message_.barometerMessage_; } + inline const Barometer& barometerMessage() const { return message_.barometerMessage_; } + + static constexpr char const* ACCELEROMETERMESSAGE_NAME = "accelerometerMessage"; + inline bool has_accelerometerMessage() const + { + return FieldNumber::ACCELEROMETERMESSAGE == which_message_; + } + inline void clear_accelerometerMessage() + { + if(FieldNumber::ACCELEROMETERMESSAGE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.accelerometerMessage_.~Accelerometer(); + } + } + inline void set_accelerometerMessage(const Accelerometer& value) + { + if(FieldNumber::ACCELEROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::ACCELEROMETERMESSAGE); + } + message_.accelerometerMessage_ = value; + } + inline void set_accelerometerMessage(const Accelerometer&& value) + { + if(FieldNumber::ACCELEROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::ACCELEROMETERMESSAGE); + } + message_.accelerometerMessage_ = value; + } + inline Accelerometer& mutable_accelerometerMessage() + { + if(FieldNumber::ACCELEROMETERMESSAGE != which_message_) + { + init_message(FieldNumber::ACCELEROMETERMESSAGE); + } + return message_.accelerometerMessage_; + } + inline const Accelerometer& get_accelerometerMessage() const { return message_.accelerometerMessage_; } + inline const Accelerometer& accelerometerMessage() const { return message_.accelerometerMessage_; } + + static constexpr char const* MAGNETOMETERMESSAGE_NAME = "magnetometerMessage"; + inline bool has_magnetometerMessage() const + { + return FieldNumber::MAGNETOMETERMESSAGE == which_message_; + } + inline void clear_magnetometerMessage() + { + if(FieldNumber::MAGNETOMETERMESSAGE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.magnetometerMessage_.~Magnetometer(); + } + } + inline void set_magnetometerMessage(const Magnetometer& value) + { + if(FieldNumber::MAGNETOMETERMESSAGE != which_message_) + { + init_message(FieldNumber::MAGNETOMETERMESSAGE); + } + message_.magnetometerMessage_ = value; + } + inline void set_magnetometerMessage(const Magnetometer&& value) + { + if(FieldNumber::MAGNETOMETERMESSAGE != which_message_) + { + init_message(FieldNumber::MAGNETOMETERMESSAGE); + } + message_.magnetometerMessage_ = value; + } + inline Magnetometer& mutable_magnetometerMessage() + { + if(FieldNumber::MAGNETOMETERMESSAGE != which_message_) + { + init_message(FieldNumber::MAGNETOMETERMESSAGE); + } + return message_.magnetometerMessage_; + } + inline const Magnetometer& get_magnetometerMessage() const { return message_.magnetometerMessage_; } + inline const Magnetometer& magnetometerMessage() const { return message_.magnetometerMessage_; } + + static constexpr char const* GYROSCOPERMESSAGE_NAME = "gyroscoperMessage"; + inline bool has_gyroscoperMessage() const + { + return FieldNumber::GYROSCOPERMESSAGE == which_message_; + } + inline void clear_gyroscoperMessage() + { + if(FieldNumber::GYROSCOPERMESSAGE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.gyroscoperMessage_.~Gyroscope(); + } + } + inline void set_gyroscoperMessage(const Gyroscope& value) + { + if(FieldNumber::GYROSCOPERMESSAGE != which_message_) + { + init_message(FieldNumber::GYROSCOPERMESSAGE); + } + message_.gyroscoperMessage_ = value; + } + inline void set_gyroscoperMessage(const Gyroscope&& value) + { + if(FieldNumber::GYROSCOPERMESSAGE != which_message_) + { + init_message(FieldNumber::GYROSCOPERMESSAGE); + } + message_.gyroscoperMessage_ = value; + } + inline Gyroscope& mutable_gyroscoperMessage() + { + if(FieldNumber::GYROSCOPERMESSAGE != which_message_) + { + init_message(FieldNumber::GYROSCOPERMESSAGE); + } + return message_.gyroscoperMessage_; + } + inline const Gyroscope& get_gyroscoperMessage() const { return message_.gyroscoperMessage_; } + inline const Gyroscope& gyroscoperMessage() const { return message_.gyroscoperMessage_; } + + static constexpr char const* THERMOCOUPLEMESSAGE_NAME = "thermocoupleMessage"; + inline bool has_thermocoupleMessage() const + { + return FieldNumber::THERMOCOUPLEMESSAGE == which_message_; + } + inline void clear_thermocoupleMessage() + { + if(FieldNumber::THERMOCOUPLEMESSAGE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.thermocoupleMessage_.~Thermocouple(); + } + } + inline void set_thermocoupleMessage(const Thermocouple& value) + { + if(FieldNumber::THERMOCOUPLEMESSAGE != which_message_) + { + init_message(FieldNumber::THERMOCOUPLEMESSAGE); + } + message_.thermocoupleMessage_ = value; + } + inline void set_thermocoupleMessage(const Thermocouple&& value) + { + if(FieldNumber::THERMOCOUPLEMESSAGE != which_message_) + { + init_message(FieldNumber::THERMOCOUPLEMESSAGE); + } + message_.thermocoupleMessage_ = value; + } + inline Thermocouple& mutable_thermocoupleMessage() + { + if(FieldNumber::THERMOCOUPLEMESSAGE != which_message_) + { + init_message(FieldNumber::THERMOCOUPLEMESSAGE); + } + return message_.thermocoupleMessage_; + } + inline const Thermocouple& get_thermocoupleMessage() const { return message_.thermocoupleMessage_; } + inline const Thermocouple& thermocoupleMessage() const { return message_.thermocoupleMessage_; } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != timestamp_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = timestamp_.serialize_with_id(static_cast(FieldNumber::TIMESTAMP), buffer, false); + } + + switch(which_message_) + { + case FieldNumber::BAROMETERMESSAGE: + if(has_barometerMessage() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.barometerMessage_.serialize_with_id(static_cast(FieldNumber::BAROMETERMESSAGE), buffer, true); + } + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + if(has_accelerometerMessage() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.accelerometerMessage_.serialize_with_id(static_cast(FieldNumber::ACCELEROMETERMESSAGE), buffer, true); + } + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + if(has_magnetometerMessage() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.magnetometerMessage_.serialize_with_id(static_cast(FieldNumber::MAGNETOMETERMESSAGE), buffer, true); + } + break; + + case FieldNumber::GYROSCOPERMESSAGE: + if(has_gyroscoperMessage() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.gyroscoperMessage_.serialize_with_id(static_cast(FieldNumber::GYROSCOPERMESSAGE), buffer, true); + } + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + if(has_thermocoupleMessage() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.thermocoupleMessage_.serialize_with_id(static_cast(FieldNumber::THERMOCOUPLEMESSAGE), buffer, true); + } + break; + + default: + break; + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TIMESTAMP: + return_value = timestamp_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::BAROMETERMESSAGE: + case FieldNumber::ACCELEROMETERMESSAGE: + case FieldNumber::MAGNETOMETERMESSAGE: + case FieldNumber::GYROSCOPERMESSAGE: + case FieldNumber::THERMOCOUPLEMESSAGE: + return_value = deserialize_message(id_tag, buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_timestamp(); + clear_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TIMESTAMP: + name = TIMESTAMP_NAME; + break; + case FieldNumber::BAROMETERMESSAGE: + name = BAROMETERMESSAGE_NAME; + break; + case FieldNumber::ACCELEROMETERMESSAGE: + name = ACCELEROMETERMESSAGE_NAME; + break; + case FieldNumber::MAGNETOMETERMESSAGE: + name = MAGNETOMETERMESSAGE_NAME; + break; + case FieldNumber::GYROSCOPERMESSAGE: + name = GYROSCOPERMESSAGE_NAME; + break; + case FieldNumber::THERMOCOUPLEMESSAGE: + name = THERMOCOUPLEMESSAGE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = timestamp_.to_string(left_chars, indent_level + 2, TIMESTAMP_NAME, true); + left_chars = to_string_message(left_chars, indent_level + 2, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 timestamp_ = 0U; + + FieldNumber which_message_ = FieldNumber::NOT_SET; + union message + { + message() {} + ~message() {} + Barometer barometerMessage_; + Accelerometer accelerometerMessage_; + Magnetometer magnetometerMessage_; + Gyroscope gyroscoperMessage_; + Thermocouple thermocoupleMessage_; + }; + message message_; + + void init_message(const FieldNumber field_id) + { + if(FieldNumber::NOT_SET != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + // C++11 unions only support nontrivial members when you explicitly call the placement new statement. + switch(field_id) + { + case FieldNumber::BAROMETERMESSAGE: + new(&message_.barometerMessage_) Barometer; + break; + + case FieldNumber::ACCELEROMETERMESSAGE: + new(&message_.accelerometerMessage_) Accelerometer; + break; + + case FieldNumber::MAGNETOMETERMESSAGE: + new(&message_.magnetometerMessage_) Magnetometer; + break; + + case FieldNumber::GYROSCOPERMESSAGE: + new(&message_.gyroscoperMessage_) Gyroscope; + break; + + case FieldNumber::THERMOCOUPLEMESSAGE: + new(&message_.thermocoupleMessage_) Thermocouple; + break; + + default: + break; + } + + which_message_ = field_id; + } + + void clear_message() + { + switch(which_message_) + { + case FieldNumber::BAROMETERMESSAGE: + ::EmbeddedProto::destroy_at(&message_.barometerMessage_); + break; + case FieldNumber::ACCELEROMETERMESSAGE: + ::EmbeddedProto::destroy_at(&message_.accelerometerMessage_); + break; + case FieldNumber::MAGNETOMETERMESSAGE: + ::EmbeddedProto::destroy_at(&message_.magnetometerMessage_); + break; + case FieldNumber::GYROSCOPERMESSAGE: + ::EmbeddedProto::destroy_at(&message_.gyroscoperMessage_); + break; + case FieldNumber::THERMOCOUPLEMESSAGE: + ::EmbeddedProto::destroy_at(&message_.thermocoupleMessage_); + break; + default: + break; + } + which_message_ = FieldNumber::NOT_SET; + } + + ::EmbeddedProto::Error deserialize_message(const FieldNumber field_id, + ::EmbeddedProto::ReadBufferInterface& buffer, + const ::EmbeddedProto::WireFormatter::WireType wire_type) + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(field_id != which_message_) + { + init_message(field_id); + } + + switch(which_message_) + { + case FieldNumber::BAROMETERMESSAGE: + return_value = message_.barometerMessage_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::ACCELEROMETERMESSAGE: + return_value = message_.accelerometerMessage_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::MAGNETOMETERMESSAGE: + return_value = message_.magnetometerMessage_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::GYROSCOPERMESSAGE: + return_value = message_.gyroscoperMessage_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::THERMOCOUPLEMESSAGE: + return_value = message_.thermocoupleMessage_.deserialize_check_type(buffer, wire_type); + break; + default: + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS != return_value) + { + clear_message(); + } + return return_value; + } + +#ifdef MSG_TO_STRING + ::EmbeddedProto::string_view to_string_message(::EmbeddedProto::string_view& str, const uint32_t indent_level, const bool first_field) const + { + ::EmbeddedProto::string_view left_chars = str; + + switch(which_message_) + { + case FieldNumber::BAROMETERMESSAGE: + left_chars = message_.barometerMessage_.to_string(left_chars, indent_level, BAROMETERMESSAGE_NAME, first_field); + break; + case FieldNumber::ACCELEROMETERMESSAGE: + left_chars = message_.accelerometerMessage_.to_string(left_chars, indent_level, ACCELEROMETERMESSAGE_NAME, first_field); + break; + case FieldNumber::MAGNETOMETERMESSAGE: + left_chars = message_.magnetometerMessage_.to_string(left_chars, indent_level, MAGNETOMETERMESSAGE_NAME, first_field); + break; + case FieldNumber::GYROSCOPERMESSAGE: + left_chars = message_.gyroscoperMessage_.to_string(left_chars, indent_level, GYROSCOPERMESSAGE_NAME, first_field); + break; + case FieldNumber::THERMOCOUPLEMESSAGE: + left_chars = message_.thermocoupleMessage_.to_string(left_chars, indent_level, THERMOCOUPLEMESSAGE_NAME, first_field); + break; + default: + break; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING +}; + +} // End of namespace Proto +#endif // SENSORDATA_H \ No newline at end of file diff --git a/SoarProto/_C++/TelemetryMessage.hpp b/SoarProto/_C++/TelemetryMessage.hpp new file mode 100644 index 0000000..d108b82 --- /dev/null +++ b/SoarProto/_C++/TelemetryMessage.hpp @@ -0,0 +1,6914 @@ +/* + * This file is generated with Embedded Proto, PLEASE DO NOT EDIT! + * source: TelemetryMessage.proto + */ + +// This file is generated. Please do not edit! +#ifndef TELEMETRYMESSAGE_H +#define TELEMETRYMESSAGE_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Include external proto definitions +#include "CoreProto.h" + +namespace Proto { + +class AltitudeType final: public ::EmbeddedProto::MessageInterface +{ + public: + AltitudeType() = default; + AltitudeType(const AltitudeType& rhs ) + { + set_altitude(rhs.get_altitude()); + set_unit(rhs.get_unit()); + } + + AltitudeType(const AltitudeType&& rhs ) noexcept + { + set_altitude(rhs.get_altitude()); + set_unit(rhs.get_unit()); + } + + ~AltitudeType() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + ALTITUDE = 1, + UNIT = 2 + }; + + AltitudeType& operator=(const AltitudeType& rhs) + { + set_altitude(rhs.get_altitude()); + set_unit(rhs.get_unit()); + return *this; + } + + AltitudeType& operator=(const AltitudeType&& rhs) noexcept + { + set_altitude(rhs.get_altitude()); + set_unit(rhs.get_unit()); + return *this; + } + + static constexpr char const* ALTITUDE_NAME = "altitude"; + inline void clear_altitude() { altitude_.clear(); } + inline void set_altitude(const int32_t& value) { altitude_ = value; } + inline void set_altitude(const int32_t&& value) { altitude_ = value; } + inline int32_t& mutable_altitude() { return altitude_.get(); } + inline const int32_t& get_altitude() const { return altitude_.get(); } + inline int32_t altitude() const { return altitude_.get(); } + + static constexpr char const* UNIT_NAME = "unit"; + inline void clear_unit() { unit_.clear(); } + inline void set_unit(const int32_t& value) { unit_ = value; } + inline void set_unit(const int32_t&& value) { unit_ = value; } + inline int32_t& mutable_unit() { return unit_.get(); } + inline const int32_t& get_unit() const { return unit_.get(); } + inline int32_t unit() const { return unit_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != altitude_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = altitude_.serialize_with_id(static_cast(FieldNumber::ALTITUDE), buffer, false); + } + + if((0 != unit_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = unit_.serialize_with_id(static_cast(FieldNumber::UNIT), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::ALTITUDE: + return_value = altitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::UNIT: + return_value = unit_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_altitude(); + clear_unit(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::ALTITUDE: + name = ALTITUDE_NAME; + break; + case FieldNumber::UNIT: + name = UNIT_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = altitude_.to_string(left_chars, indent_level + 2, ALTITUDE_NAME, true); + left_chars = unit_.to_string(left_chars, indent_level + 2, UNIT_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 altitude_ = 0; + EmbeddedProto::int32 unit_ = 0; + +}; + +class Baro final: public ::EmbeddedProto::MessageInterface +{ + public: + Baro() = default; + Baro(const Baro& rhs ) + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + } + + Baro(const Baro&& rhs ) noexcept + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + } + + ~Baro() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + BARO_PRESSURE = 1, + BARO_TEMPERATURE = 2 + }; + + Baro& operator=(const Baro& rhs) + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + return *this; + } + + Baro& operator=(const Baro&& rhs) noexcept + { + set_baro_pressure(rhs.get_baro_pressure()); + set_baro_temperature(rhs.get_baro_temperature()); + return *this; + } + + static constexpr char const* BARO_PRESSURE_NAME = "baro_pressure"; + inline void clear_baro_pressure() { baro_pressure_.clear(); } + inline void set_baro_pressure(const int32_t& value) { baro_pressure_ = value; } + inline void set_baro_pressure(const int32_t&& value) { baro_pressure_ = value; } + inline int32_t& mutable_baro_pressure() { return baro_pressure_.get(); } + inline const int32_t& get_baro_pressure() const { return baro_pressure_.get(); } + inline int32_t baro_pressure() const { return baro_pressure_.get(); } + + static constexpr char const* BARO_TEMPERATURE_NAME = "baro_temperature"; + inline void clear_baro_temperature() { baro_temperature_.clear(); } + inline void set_baro_temperature(const int32_t& value) { baro_temperature_ = value; } + inline void set_baro_temperature(const int32_t&& value) { baro_temperature_ = value; } + inline int32_t& mutable_baro_temperature() { return baro_temperature_.get(); } + inline const int32_t& get_baro_temperature() const { return baro_temperature_.get(); } + inline int32_t baro_temperature() const { return baro_temperature_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != baro_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = baro_pressure_.serialize_with_id(static_cast(FieldNumber::BARO_PRESSURE), buffer, false); + } + + if((0 != baro_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = baro_temperature_.serialize_with_id(static_cast(FieldNumber::BARO_TEMPERATURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::BARO_PRESSURE: + return_value = baro_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::BARO_TEMPERATURE: + return_value = baro_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_baro_pressure(); + clear_baro_temperature(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::BARO_PRESSURE: + name = BARO_PRESSURE_NAME; + break; + case FieldNumber::BARO_TEMPERATURE: + name = BARO_TEMPERATURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = baro_pressure_.to_string(left_chars, indent_level + 2, BARO_PRESSURE_NAME, true); + left_chars = baro_temperature_.to_string(left_chars, indent_level + 2, BARO_TEMPERATURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 baro_pressure_ = 0; + EmbeddedProto::int32 baro_temperature_ = 0; + +}; + +class Battery final: public ::EmbeddedProto::MessageInterface +{ + public: + Battery() = default; + Battery(const Battery& rhs ) + { + set_power_source(rhs.get_power_source()); + set_voltage(rhs.get_voltage()); + } + + Battery(const Battery&& rhs ) noexcept + { + set_power_source(rhs.get_power_source()); + set_voltage(rhs.get_voltage()); + } + + ~Battery() override = default; + + enum class PowerSource : uint32_t + { + INVALID = 0, + GROUND = 1, + ROCKET = 2 + }; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + POWER_SOURCE = 1, + VOLTAGE = 2 + }; + + Battery& operator=(const Battery& rhs) + { + set_power_source(rhs.get_power_source()); + set_voltage(rhs.get_voltage()); + return *this; + } + + Battery& operator=(const Battery&& rhs) noexcept + { + set_power_source(rhs.get_power_source()); + set_voltage(rhs.get_voltage()); + return *this; + } + + static constexpr char const* POWER_SOURCE_NAME = "power_source"; + inline void clear_power_source() { power_source_.clear(); } + inline void set_power_source(const PowerSource& value) { power_source_ = value; } + inline void set_power_source(const PowerSource&& value) { power_source_ = value; } + inline const PowerSource& get_power_source() const { return power_source_.get(); } + inline PowerSource power_source() const { return power_source_.get(); } + + static constexpr char const* VOLTAGE_NAME = "voltage"; + inline void clear_voltage() { voltage_.clear(); } + inline void set_voltage(const int32_t& value) { voltage_ = value; } + inline void set_voltage(const int32_t&& value) { voltage_ = value; } + inline int32_t& mutable_voltage() { return voltage_.get(); } + inline const int32_t& get_voltage() const { return voltage_.get(); } + inline int32_t voltage() const { return voltage_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != power_source_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = power_source_.serialize_with_id(static_cast(FieldNumber::POWER_SOURCE), buffer, false); + } + + if((0 != voltage_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = voltage_.serialize_with_id(static_cast(FieldNumber::VOLTAGE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::POWER_SOURCE: + return_value = power_source_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::VOLTAGE: + return_value = voltage_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_power_source(); + clear_voltage(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::POWER_SOURCE: + name = POWER_SOURCE_NAME; + break; + case FieldNumber::VOLTAGE: + name = VOLTAGE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = power_source_.to_string(left_chars, indent_level + 2, POWER_SOURCE_NAME, true); + left_chars = voltage_.to_string(left_chars, indent_level + 2, VOLTAGE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration power_source_ = static_cast(0); + EmbeddedProto::int32 voltage_ = 0; + +}; + +class CombustionControlStatus final: public ::EmbeddedProto::MessageInterface +{ + public: + CombustionControlStatus() = default; + CombustionControlStatus(const CombustionControlStatus& rhs ) + { + set_vent_open(rhs.get_vent_open()); + set_drain_open(rhs.get_drain_open()); + set_mev_open(rhs.get_mev_open()); + } + + CombustionControlStatus(const CombustionControlStatus&& rhs ) noexcept + { + set_vent_open(rhs.get_vent_open()); + set_drain_open(rhs.get_drain_open()); + set_mev_open(rhs.get_mev_open()); + } + + ~CombustionControlStatus() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + VENT_OPEN = 1, + DRAIN_OPEN = 2, + MEV_OPEN = 3 + }; + + CombustionControlStatus& operator=(const CombustionControlStatus& rhs) + { + set_vent_open(rhs.get_vent_open()); + set_drain_open(rhs.get_drain_open()); + set_mev_open(rhs.get_mev_open()); + return *this; + } + + CombustionControlStatus& operator=(const CombustionControlStatus&& rhs) noexcept + { + set_vent_open(rhs.get_vent_open()); + set_drain_open(rhs.get_drain_open()); + set_mev_open(rhs.get_mev_open()); + return *this; + } + + static constexpr char const* VENT_OPEN_NAME = "vent_open"; + inline void clear_vent_open() { vent_open_.clear(); } + inline void set_vent_open(const bool& value) { vent_open_ = value; } + inline void set_vent_open(const bool&& value) { vent_open_ = value; } + inline bool& mutable_vent_open() { return vent_open_.get(); } + inline const bool& get_vent_open() const { return vent_open_.get(); } + inline bool vent_open() const { return vent_open_.get(); } + + static constexpr char const* DRAIN_OPEN_NAME = "drain_open"; + inline void clear_drain_open() { drain_open_.clear(); } + inline void set_drain_open(const bool& value) { drain_open_ = value; } + inline void set_drain_open(const bool&& value) { drain_open_ = value; } + inline bool& mutable_drain_open() { return drain_open_.get(); } + inline const bool& get_drain_open() const { return drain_open_.get(); } + inline bool drain_open() const { return drain_open_.get(); } + + static constexpr char const* MEV_OPEN_NAME = "mev_open"; + inline void clear_mev_open() { mev_open_.clear(); } + inline void set_mev_open(const bool& value) { mev_open_ = value; } + inline void set_mev_open(const bool&& value) { mev_open_ = value; } + inline bool& mutable_mev_open() { return mev_open_.get(); } + inline const bool& get_mev_open() const { return mev_open_.get(); } + inline bool mev_open() const { return mev_open_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((false != vent_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = vent_open_.serialize_with_id(static_cast(FieldNumber::VENT_OPEN), buffer, false); + } + + if((false != drain_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = drain_open_.serialize_with_id(static_cast(FieldNumber::DRAIN_OPEN), buffer, false); + } + + if((false != mev_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mev_open_.serialize_with_id(static_cast(FieldNumber::MEV_OPEN), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::VENT_OPEN: + return_value = vent_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::DRAIN_OPEN: + return_value = drain_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MEV_OPEN: + return_value = mev_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_vent_open(); + clear_drain_open(); + clear_mev_open(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::VENT_OPEN: + name = VENT_OPEN_NAME; + break; + case FieldNumber::DRAIN_OPEN: + name = DRAIN_OPEN_NAME; + break; + case FieldNumber::MEV_OPEN: + name = MEV_OPEN_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = vent_open_.to_string(left_chars, indent_level + 2, VENT_OPEN_NAME, true); + left_chars = drain_open_.to_string(left_chars, indent_level + 2, DRAIN_OPEN_NAME, false); + left_chars = mev_open_.to_string(left_chars, indent_level + 2, MEV_OPEN_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::boolean vent_open_ = false; + EmbeddedProto::boolean drain_open_ = false; + EmbeddedProto::boolean mev_open_ = false; + +}; + +class CoordinateType final: public ::EmbeddedProto::MessageInterface +{ + public: + CoordinateType() = default; + CoordinateType(const CoordinateType& rhs ) + { + set_degrees(rhs.get_degrees()); + set_minutes(rhs.get_minutes()); + } + + CoordinateType(const CoordinateType&& rhs ) noexcept + { + set_degrees(rhs.get_degrees()); + set_minutes(rhs.get_minutes()); + } + + ~CoordinateType() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + DEGREES = 1, + MINUTES = 2 + }; + + CoordinateType& operator=(const CoordinateType& rhs) + { + set_degrees(rhs.get_degrees()); + set_minutes(rhs.get_minutes()); + return *this; + } + + CoordinateType& operator=(const CoordinateType&& rhs) noexcept + { + set_degrees(rhs.get_degrees()); + set_minutes(rhs.get_minutes()); + return *this; + } + + static constexpr char const* DEGREES_NAME = "degrees"; + inline void clear_degrees() { degrees_.clear(); } + inline void set_degrees(const int32_t& value) { degrees_ = value; } + inline void set_degrees(const int32_t&& value) { degrees_ = value; } + inline int32_t& mutable_degrees() { return degrees_.get(); } + inline const int32_t& get_degrees() const { return degrees_.get(); } + inline int32_t degrees() const { return degrees_.get(); } + + static constexpr char const* MINUTES_NAME = "minutes"; + inline void clear_minutes() { minutes_.clear(); } + inline void set_minutes(const int32_t& value) { minutes_ = value; } + inline void set_minutes(const int32_t&& value) { minutes_ = value; } + inline int32_t& mutable_minutes() { return minutes_.get(); } + inline const int32_t& get_minutes() const { return minutes_.get(); } + inline int32_t minutes() const { return minutes_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != degrees_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = degrees_.serialize_with_id(static_cast(FieldNumber::DEGREES), buffer, false); + } + + if((0 != minutes_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = minutes_.serialize_with_id(static_cast(FieldNumber::MINUTES), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::DEGREES: + return_value = degrees_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MINUTES: + return_value = minutes_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_degrees(); + clear_minutes(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::DEGREES: + name = DEGREES_NAME; + break; + case FieldNumber::MINUTES: + name = MINUTES_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = degrees_.to_string(left_chars, indent_level + 2, DEGREES_NAME, true); + left_chars = minutes_.to_string(left_chars, indent_level + 2, MINUTES_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 degrees_ = 0; + EmbeddedProto::int32 minutes_ = 0; + +}; + +class DmbPressure final: public ::EmbeddedProto::MessageInterface +{ + public: + DmbPressure() = default; + DmbPressure(const DmbPressure& rhs ) + { + set_upper_pv_pressure(rhs.get_upper_pv_pressure()); + } + + DmbPressure(const DmbPressure&& rhs ) noexcept + { + set_upper_pv_pressure(rhs.get_upper_pv_pressure()); + } + + ~DmbPressure() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + UPPER_PV_PRESSURE = 1 + }; + + DmbPressure& operator=(const DmbPressure& rhs) + { + set_upper_pv_pressure(rhs.get_upper_pv_pressure()); + return *this; + } + + DmbPressure& operator=(const DmbPressure&& rhs) noexcept + { + set_upper_pv_pressure(rhs.get_upper_pv_pressure()); + return *this; + } + + static constexpr char const* UPPER_PV_PRESSURE_NAME = "upper_pv_pressure"; + inline void clear_upper_pv_pressure() { upper_pv_pressure_.clear(); } + inline void set_upper_pv_pressure(const int32_t& value) { upper_pv_pressure_ = value; } + inline void set_upper_pv_pressure(const int32_t&& value) { upper_pv_pressure_ = value; } + inline int32_t& mutable_upper_pv_pressure() { return upper_pv_pressure_.get(); } + inline const int32_t& get_upper_pv_pressure() const { return upper_pv_pressure_.get(); } + inline int32_t upper_pv_pressure() const { return upper_pv_pressure_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != upper_pv_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = upper_pv_pressure_.serialize_with_id(static_cast(FieldNumber::UPPER_PV_PRESSURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::UPPER_PV_PRESSURE: + return_value = upper_pv_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_upper_pv_pressure(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::UPPER_PV_PRESSURE: + name = UPPER_PV_PRESSURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = upper_pv_pressure_.to_string(left_chars, indent_level + 2, UPPER_PV_PRESSURE_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 upper_pv_pressure_ = 0; + +}; + +class Flash final: public ::EmbeddedProto::MessageInterface +{ + public: + Flash() = default; + Flash(const Flash& rhs ) + { + set_sector_address(rhs.get_sector_address()); + set_logging_rate(rhs.get_logging_rate()); + } + + Flash(const Flash&& rhs ) noexcept + { + set_sector_address(rhs.get_sector_address()); + set_logging_rate(rhs.get_logging_rate()); + } + + ~Flash() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SECTOR_ADDRESS = 1, + LOGGING_RATE = 2 + }; + + Flash& operator=(const Flash& rhs) + { + set_sector_address(rhs.get_sector_address()); + set_logging_rate(rhs.get_logging_rate()); + return *this; + } + + Flash& operator=(const Flash&& rhs) noexcept + { + set_sector_address(rhs.get_sector_address()); + set_logging_rate(rhs.get_logging_rate()); + return *this; + } + + static constexpr char const* SECTOR_ADDRESS_NAME = "sector_address"; + inline void clear_sector_address() { sector_address_.clear(); } + inline void set_sector_address(const uint32_t& value) { sector_address_ = value; } + inline void set_sector_address(const uint32_t&& value) { sector_address_ = value; } + inline uint32_t& mutable_sector_address() { return sector_address_.get(); } + inline const uint32_t& get_sector_address() const { return sector_address_.get(); } + inline uint32_t sector_address() const { return sector_address_.get(); } + + static constexpr char const* LOGGING_RATE_NAME = "logging_rate"; + inline void clear_logging_rate() { logging_rate_.clear(); } + inline void set_logging_rate(const uint32_t& value) { logging_rate_ = value; } + inline void set_logging_rate(const uint32_t&& value) { logging_rate_ = value; } + inline uint32_t& mutable_logging_rate() { return logging_rate_.get(); } + inline const uint32_t& get_logging_rate() const { return logging_rate_.get(); } + inline uint32_t logging_rate() const { return logging_rate_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != sector_address_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sector_address_.serialize_with_id(static_cast(FieldNumber::SECTOR_ADDRESS), buffer, false); + } + + if((0U != logging_rate_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = logging_rate_.serialize_with_id(static_cast(FieldNumber::LOGGING_RATE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SECTOR_ADDRESS: + return_value = sector_address_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOGGING_RATE: + return_value = logging_rate_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_sector_address(); + clear_logging_rate(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SECTOR_ADDRESS: + name = SECTOR_ADDRESS_NAME; + break; + case FieldNumber::LOGGING_RATE: + name = LOGGING_RATE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = sector_address_.to_string(left_chars, indent_level + 2, SECTOR_ADDRESS_NAME, true); + left_chars = logging_rate_.to_string(left_chars, indent_level + 2, LOGGING_RATE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 sector_address_ = 0U; + EmbeddedProto::uint32 logging_rate_ = 0U; + +}; + +class Imu final: public ::EmbeddedProto::MessageInterface +{ + public: + Imu() = default; + Imu(const Imu& rhs ) + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + } + + Imu(const Imu&& rhs ) noexcept + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + } + + ~Imu() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + ACCEL_X = 1, + ACCEL_Y = 2, + ACCEL_Z = 3, + GYRO_X = 4, + GYRO_Y = 5, + GYRO_Z = 6, + MAG_X = 7, + MAG_Y = 8, + MAG_Z = 9 + }; + + Imu& operator=(const Imu& rhs) + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + return *this; + } + + Imu& operator=(const Imu&& rhs) noexcept + { + set_accel_x(rhs.get_accel_x()); + set_accel_y(rhs.get_accel_y()); + set_accel_z(rhs.get_accel_z()); + set_gyro_x(rhs.get_gyro_x()); + set_gyro_y(rhs.get_gyro_y()); + set_gyro_z(rhs.get_gyro_z()); + set_mag_x(rhs.get_mag_x()); + set_mag_y(rhs.get_mag_y()); + set_mag_z(rhs.get_mag_z()); + return *this; + } + + static constexpr char const* ACCEL_X_NAME = "accel_x"; + inline void clear_accel_x() { accel_x_.clear(); } + inline void set_accel_x(const int32_t& value) { accel_x_ = value; } + inline void set_accel_x(const int32_t&& value) { accel_x_ = value; } + inline int32_t& mutable_accel_x() { return accel_x_.get(); } + inline const int32_t& get_accel_x() const { return accel_x_.get(); } + inline int32_t accel_x() const { return accel_x_.get(); } + + static constexpr char const* ACCEL_Y_NAME = "accel_y"; + inline void clear_accel_y() { accel_y_.clear(); } + inline void set_accel_y(const int32_t& value) { accel_y_ = value; } + inline void set_accel_y(const int32_t&& value) { accel_y_ = value; } + inline int32_t& mutable_accel_y() { return accel_y_.get(); } + inline const int32_t& get_accel_y() const { return accel_y_.get(); } + inline int32_t accel_y() const { return accel_y_.get(); } + + static constexpr char const* ACCEL_Z_NAME = "accel_z"; + inline void clear_accel_z() { accel_z_.clear(); } + inline void set_accel_z(const int32_t& value) { accel_z_ = value; } + inline void set_accel_z(const int32_t&& value) { accel_z_ = value; } + inline int32_t& mutable_accel_z() { return accel_z_.get(); } + inline const int32_t& get_accel_z() const { return accel_z_.get(); } + inline int32_t accel_z() const { return accel_z_.get(); } + + static constexpr char const* GYRO_X_NAME = "gyro_x"; + inline void clear_gyro_x() { gyro_x_.clear(); } + inline void set_gyro_x(const int32_t& value) { gyro_x_ = value; } + inline void set_gyro_x(const int32_t&& value) { gyro_x_ = value; } + inline int32_t& mutable_gyro_x() { return gyro_x_.get(); } + inline const int32_t& get_gyro_x() const { return gyro_x_.get(); } + inline int32_t gyro_x() const { return gyro_x_.get(); } + + static constexpr char const* GYRO_Y_NAME = "gyro_y"; + inline void clear_gyro_y() { gyro_y_.clear(); } + inline void set_gyro_y(const int32_t& value) { gyro_y_ = value; } + inline void set_gyro_y(const int32_t&& value) { gyro_y_ = value; } + inline int32_t& mutable_gyro_y() { return gyro_y_.get(); } + inline const int32_t& get_gyro_y() const { return gyro_y_.get(); } + inline int32_t gyro_y() const { return gyro_y_.get(); } + + static constexpr char const* GYRO_Z_NAME = "gyro_z"; + inline void clear_gyro_z() { gyro_z_.clear(); } + inline void set_gyro_z(const int32_t& value) { gyro_z_ = value; } + inline void set_gyro_z(const int32_t&& value) { gyro_z_ = value; } + inline int32_t& mutable_gyro_z() { return gyro_z_.get(); } + inline const int32_t& get_gyro_z() const { return gyro_z_.get(); } + inline int32_t gyro_z() const { return gyro_z_.get(); } + + static constexpr char const* MAG_X_NAME = "mag_x"; + inline void clear_mag_x() { mag_x_.clear(); } + inline void set_mag_x(const int32_t& value) { mag_x_ = value; } + inline void set_mag_x(const int32_t&& value) { mag_x_ = value; } + inline int32_t& mutable_mag_x() { return mag_x_.get(); } + inline const int32_t& get_mag_x() const { return mag_x_.get(); } + inline int32_t mag_x() const { return mag_x_.get(); } + + static constexpr char const* MAG_Y_NAME = "mag_y"; + inline void clear_mag_y() { mag_y_.clear(); } + inline void set_mag_y(const int32_t& value) { mag_y_ = value; } + inline void set_mag_y(const int32_t&& value) { mag_y_ = value; } + inline int32_t& mutable_mag_y() { return mag_y_.get(); } + inline const int32_t& get_mag_y() const { return mag_y_.get(); } + inline int32_t mag_y() const { return mag_y_.get(); } + + static constexpr char const* MAG_Z_NAME = "mag_z"; + inline void clear_mag_z() { mag_z_.clear(); } + inline void set_mag_z(const int32_t& value) { mag_z_ = value; } + inline void set_mag_z(const int32_t&& value) { mag_z_ = value; } + inline int32_t& mutable_mag_z() { return mag_z_.get(); } + inline const int32_t& get_mag_z() const { return mag_z_.get(); } + inline int32_t mag_z() const { return mag_z_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != accel_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_x_.serialize_with_id(static_cast(FieldNumber::ACCEL_X), buffer, false); + } + + if((0 != accel_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_y_.serialize_with_id(static_cast(FieldNumber::ACCEL_Y), buffer, false); + } + + if((0 != accel_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = accel_z_.serialize_with_id(static_cast(FieldNumber::ACCEL_Z), buffer, false); + } + + if((0 != gyro_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_x_.serialize_with_id(static_cast(FieldNumber::GYRO_X), buffer, false); + } + + if((0 != gyro_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_y_.serialize_with_id(static_cast(FieldNumber::GYRO_Y), buffer, false); + } + + if((0 != gyro_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = gyro_z_.serialize_with_id(static_cast(FieldNumber::GYRO_Z), buffer, false); + } + + if((0 != mag_x_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_x_.serialize_with_id(static_cast(FieldNumber::MAG_X), buffer, false); + } + + if((0 != mag_y_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_y_.serialize_with_id(static_cast(FieldNumber::MAG_Y), buffer, false); + } + + if((0 != mag_z_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = mag_z_.serialize_with_id(static_cast(FieldNumber::MAG_Z), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::ACCEL_X: + return_value = accel_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACCEL_Y: + return_value = accel_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ACCEL_Z: + return_value = accel_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GYRO_X: + return_value = gyro_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GYRO_Y: + return_value = gyro_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GYRO_Z: + return_value = gyro_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MAG_X: + return_value = mag_x_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MAG_Y: + return_value = mag_y_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::MAG_Z: + return_value = mag_z_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_accel_x(); + clear_accel_y(); + clear_accel_z(); + clear_gyro_x(); + clear_gyro_y(); + clear_gyro_z(); + clear_mag_x(); + clear_mag_y(); + clear_mag_z(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::ACCEL_X: + name = ACCEL_X_NAME; + break; + case FieldNumber::ACCEL_Y: + name = ACCEL_Y_NAME; + break; + case FieldNumber::ACCEL_Z: + name = ACCEL_Z_NAME; + break; + case FieldNumber::GYRO_X: + name = GYRO_X_NAME; + break; + case FieldNumber::GYRO_Y: + name = GYRO_Y_NAME; + break; + case FieldNumber::GYRO_Z: + name = GYRO_Z_NAME; + break; + case FieldNumber::MAG_X: + name = MAG_X_NAME; + break; + case FieldNumber::MAG_Y: + name = MAG_Y_NAME; + break; + case FieldNumber::MAG_Z: + name = MAG_Z_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = accel_x_.to_string(left_chars, indent_level + 2, ACCEL_X_NAME, true); + left_chars = accel_y_.to_string(left_chars, indent_level + 2, ACCEL_Y_NAME, false); + left_chars = accel_z_.to_string(left_chars, indent_level + 2, ACCEL_Z_NAME, false); + left_chars = gyro_x_.to_string(left_chars, indent_level + 2, GYRO_X_NAME, false); + left_chars = gyro_y_.to_string(left_chars, indent_level + 2, GYRO_Y_NAME, false); + left_chars = gyro_z_.to_string(left_chars, indent_level + 2, GYRO_Z_NAME, false); + left_chars = mag_x_.to_string(left_chars, indent_level + 2, MAG_X_NAME, false); + left_chars = mag_y_.to_string(left_chars, indent_level + 2, MAG_Y_NAME, false); + left_chars = mag_z_.to_string(left_chars, indent_level + 2, MAG_Z_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 accel_x_ = 0; + EmbeddedProto::int32 accel_y_ = 0; + EmbeddedProto::int32 accel_z_ = 0; + EmbeddedProto::int32 gyro_x_ = 0; + EmbeddedProto::int32 gyro_y_ = 0; + EmbeddedProto::int32 gyro_z_ = 0; + EmbeddedProto::int32 mag_x_ = 0; + EmbeddedProto::int32 mag_y_ = 0; + EmbeddedProto::int32 mag_z_ = 0; + +}; + +class LaunchRailLoadCell final: public ::EmbeddedProto::MessageInterface +{ + public: + LaunchRailLoadCell() = default; + LaunchRailLoadCell(const LaunchRailLoadCell& rhs ) + { + set_rocket_mass(rhs.get_rocket_mass()); + } + + LaunchRailLoadCell(const LaunchRailLoadCell&& rhs ) noexcept + { + set_rocket_mass(rhs.get_rocket_mass()); + } + + ~LaunchRailLoadCell() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + ROCKET_MASS = 1 + }; + + LaunchRailLoadCell& operator=(const LaunchRailLoadCell& rhs) + { + set_rocket_mass(rhs.get_rocket_mass()); + return *this; + } + + LaunchRailLoadCell& operator=(const LaunchRailLoadCell&& rhs) noexcept + { + set_rocket_mass(rhs.get_rocket_mass()); + return *this; + } + + static constexpr char const* ROCKET_MASS_NAME = "rocket_mass"; + inline void clear_rocket_mass() { rocket_mass_.clear(); } + inline void set_rocket_mass(const int32_t& value) { rocket_mass_ = value; } + inline void set_rocket_mass(const int32_t&& value) { rocket_mass_ = value; } + inline int32_t& mutable_rocket_mass() { return rocket_mass_.get(); } + inline const int32_t& get_rocket_mass() const { return rocket_mass_.get(); } + inline int32_t rocket_mass() const { return rocket_mass_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != rocket_mass_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = rocket_mass_.serialize_with_id(static_cast(FieldNumber::ROCKET_MASS), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::ROCKET_MASS: + return_value = rocket_mass_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_rocket_mass(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::ROCKET_MASS: + name = ROCKET_MASS_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = rocket_mass_.to_string(left_chars, indent_level + 2, ROCKET_MASS_NAME, true); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 rocket_mass_ = 0; + +}; + +class NosLoadCell final: public ::EmbeddedProto::MessageInterface +{ + public: + NosLoadCell() = default; + NosLoadCell(const NosLoadCell& rhs ) + { + set_nos1_mass(rhs.get_nos1_mass()); + set_nos2_mass(rhs.get_nos2_mass()); + } + + NosLoadCell(const NosLoadCell&& rhs ) noexcept + { + set_nos1_mass(rhs.get_nos1_mass()); + set_nos2_mass(rhs.get_nos2_mass()); + } + + ~NosLoadCell() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + NOS1_MASS = 1, + NOS2_MASS = 2 + }; + + NosLoadCell& operator=(const NosLoadCell& rhs) + { + set_nos1_mass(rhs.get_nos1_mass()); + set_nos2_mass(rhs.get_nos2_mass()); + return *this; + } + + NosLoadCell& operator=(const NosLoadCell&& rhs) noexcept + { + set_nos1_mass(rhs.get_nos1_mass()); + set_nos2_mass(rhs.get_nos2_mass()); + return *this; + } + + static constexpr char const* NOS1_MASS_NAME = "nos1_mass"; + inline void clear_nos1_mass() { nos1_mass_.clear(); } + inline void set_nos1_mass(const int32_t& value) { nos1_mass_ = value; } + inline void set_nos1_mass(const int32_t&& value) { nos1_mass_ = value; } + inline int32_t& mutable_nos1_mass() { return nos1_mass_.get(); } + inline const int32_t& get_nos1_mass() const { return nos1_mass_.get(); } + inline int32_t nos1_mass() const { return nos1_mass_.get(); } + + static constexpr char const* NOS2_MASS_NAME = "nos2_mass"; + inline void clear_nos2_mass() { nos2_mass_.clear(); } + inline void set_nos2_mass(const int32_t& value) { nos2_mass_ = value; } + inline void set_nos2_mass(const int32_t&& value) { nos2_mass_ = value; } + inline int32_t& mutable_nos2_mass() { return nos2_mass_.get(); } + inline const int32_t& get_nos2_mass() const { return nos2_mass_.get(); } + inline int32_t nos2_mass() const { return nos2_mass_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != nos1_mass_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = nos1_mass_.serialize_with_id(static_cast(FieldNumber::NOS1_MASS), buffer, false); + } + + if((0 != nos2_mass_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = nos2_mass_.serialize_with_id(static_cast(FieldNumber::NOS2_MASS), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::NOS1_MASS: + return_value = nos1_mass_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOS2_MASS: + return_value = nos2_mass_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_nos1_mass(); + clear_nos2_mass(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::NOS1_MASS: + name = NOS1_MASS_NAME; + break; + case FieldNumber::NOS2_MASS: + name = NOS2_MASS_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = nos1_mass_.to_string(left_chars, indent_level + 2, NOS1_MASS_NAME, true); + left_chars = nos2_mass_.to_string(left_chars, indent_level + 2, NOS2_MASS_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 nos1_mass_ = 0; + EmbeddedProto::int32 nos2_mass_ = 0; + +}; + +class PadBoxStatus final: public ::EmbeddedProto::MessageInterface +{ + public: + PadBoxStatus() = default; + PadBoxStatus(const PadBoxStatus& rhs ) + { + set_continuity_1(rhs.get_continuity_1()); + set_continuity_2(rhs.get_continuity_2()); + set_box1_on(rhs.get_box1_on()); + set_box2_on(rhs.get_box2_on()); + } + + PadBoxStatus(const PadBoxStatus&& rhs ) noexcept + { + set_continuity_1(rhs.get_continuity_1()); + set_continuity_2(rhs.get_continuity_2()); + set_box1_on(rhs.get_box1_on()); + set_box2_on(rhs.get_box2_on()); + } + + ~PadBoxStatus() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + CONTINUITY_1 = 1, + CONTINUITY_2 = 2, + BOX1_ON = 3, + BOX2_ON = 4 + }; + + PadBoxStatus& operator=(const PadBoxStatus& rhs) + { + set_continuity_1(rhs.get_continuity_1()); + set_continuity_2(rhs.get_continuity_2()); + set_box1_on(rhs.get_box1_on()); + set_box2_on(rhs.get_box2_on()); + return *this; + } + + PadBoxStatus& operator=(const PadBoxStatus&& rhs) noexcept + { + set_continuity_1(rhs.get_continuity_1()); + set_continuity_2(rhs.get_continuity_2()); + set_box1_on(rhs.get_box1_on()); + set_box2_on(rhs.get_box2_on()); + return *this; + } + + static constexpr char const* CONTINUITY_1_NAME = "continuity_1"; + inline void clear_continuity_1() { continuity_1_.clear(); } + inline void set_continuity_1(const bool& value) { continuity_1_ = value; } + inline void set_continuity_1(const bool&& value) { continuity_1_ = value; } + inline bool& mutable_continuity_1() { return continuity_1_.get(); } + inline const bool& get_continuity_1() const { return continuity_1_.get(); } + inline bool continuity_1() const { return continuity_1_.get(); } + + static constexpr char const* CONTINUITY_2_NAME = "continuity_2"; + inline void clear_continuity_2() { continuity_2_.clear(); } + inline void set_continuity_2(const bool& value) { continuity_2_ = value; } + inline void set_continuity_2(const bool&& value) { continuity_2_ = value; } + inline bool& mutable_continuity_2() { return continuity_2_.get(); } + inline const bool& get_continuity_2() const { return continuity_2_.get(); } + inline bool continuity_2() const { return continuity_2_.get(); } + + static constexpr char const* BOX1_ON_NAME = "box1_on"; + inline void clear_box1_on() { box1_on_.clear(); } + inline void set_box1_on(const bool& value) { box1_on_ = value; } + inline void set_box1_on(const bool&& value) { box1_on_ = value; } + inline bool& mutable_box1_on() { return box1_on_.get(); } + inline const bool& get_box1_on() const { return box1_on_.get(); } + inline bool box1_on() const { return box1_on_.get(); } + + static constexpr char const* BOX2_ON_NAME = "box2_on"; + inline void clear_box2_on() { box2_on_.clear(); } + inline void set_box2_on(const bool& value) { box2_on_ = value; } + inline void set_box2_on(const bool&& value) { box2_on_ = value; } + inline bool& mutable_box2_on() { return box2_on_.get(); } + inline const bool& get_box2_on() const { return box2_on_.get(); } + inline bool box2_on() const { return box2_on_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((false != continuity_1_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = continuity_1_.serialize_with_id(static_cast(FieldNumber::CONTINUITY_1), buffer, false); + } + + if((false != continuity_2_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = continuity_2_.serialize_with_id(static_cast(FieldNumber::CONTINUITY_2), buffer, false); + } + + if((false != box1_on_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = box1_on_.serialize_with_id(static_cast(FieldNumber::BOX1_ON), buffer, false); + } + + if((false != box2_on_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = box2_on_.serialize_with_id(static_cast(FieldNumber::BOX2_ON), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::CONTINUITY_1: + return_value = continuity_1_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::CONTINUITY_2: + return_value = continuity_2_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::BOX1_ON: + return_value = box1_on_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::BOX2_ON: + return_value = box2_on_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_continuity_1(); + clear_continuity_2(); + clear_box1_on(); + clear_box2_on(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::CONTINUITY_1: + name = CONTINUITY_1_NAME; + break; + case FieldNumber::CONTINUITY_2: + name = CONTINUITY_2_NAME; + break; + case FieldNumber::BOX1_ON: + name = BOX1_ON_NAME; + break; + case FieldNumber::BOX2_ON: + name = BOX2_ON_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = continuity_1_.to_string(left_chars, indent_level + 2, CONTINUITY_1_NAME, true); + left_chars = continuity_2_.to_string(left_chars, indent_level + 2, CONTINUITY_2_NAME, false); + left_chars = box1_on_.to_string(left_chars, indent_level + 2, BOX1_ON_NAME, false); + left_chars = box2_on_.to_string(left_chars, indent_level + 2, BOX2_ON_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::boolean continuity_1_ = false; + EmbeddedProto::boolean continuity_2_ = false; + EmbeddedProto::boolean box1_on_ = false; + EmbeddedProto::boolean box2_on_ = false; + +}; + +class PbbPressure final: public ::EmbeddedProto::MessageInterface +{ + public: + PbbPressure() = default; + PbbPressure(const PbbPressure& rhs ) + { + set_ib_pressure(rhs.get_ib_pressure()); + set_lower_pv_pressure(rhs.get_lower_pv_pressure()); + } + + PbbPressure(const PbbPressure&& rhs ) noexcept + { + set_ib_pressure(rhs.get_ib_pressure()); + set_lower_pv_pressure(rhs.get_lower_pv_pressure()); + } + + ~PbbPressure() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + IB_PRESSURE = 1, + LOWER_PV_PRESSURE = 2 + }; + + PbbPressure& operator=(const PbbPressure& rhs) + { + set_ib_pressure(rhs.get_ib_pressure()); + set_lower_pv_pressure(rhs.get_lower_pv_pressure()); + return *this; + } + + PbbPressure& operator=(const PbbPressure&& rhs) noexcept + { + set_ib_pressure(rhs.get_ib_pressure()); + set_lower_pv_pressure(rhs.get_lower_pv_pressure()); + return *this; + } + + static constexpr char const* IB_PRESSURE_NAME = "ib_pressure"; + inline void clear_ib_pressure() { ib_pressure_.clear(); } + inline void set_ib_pressure(const int32_t& value) { ib_pressure_ = value; } + inline void set_ib_pressure(const int32_t&& value) { ib_pressure_ = value; } + inline int32_t& mutable_ib_pressure() { return ib_pressure_.get(); } + inline const int32_t& get_ib_pressure() const { return ib_pressure_.get(); } + inline int32_t ib_pressure() const { return ib_pressure_.get(); } + + static constexpr char const* LOWER_PV_PRESSURE_NAME = "lower_pv_pressure"; + inline void clear_lower_pv_pressure() { lower_pv_pressure_.clear(); } + inline void set_lower_pv_pressure(const int32_t& value) { lower_pv_pressure_ = value; } + inline void set_lower_pv_pressure(const int32_t&& value) { lower_pv_pressure_ = value; } + inline int32_t& mutable_lower_pv_pressure() { return lower_pv_pressure_.get(); } + inline const int32_t& get_lower_pv_pressure() const { return lower_pv_pressure_.get(); } + inline int32_t lower_pv_pressure() const { return lower_pv_pressure_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != ib_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ib_pressure_.serialize_with_id(static_cast(FieldNumber::IB_PRESSURE), buffer, false); + } + + if((0 != lower_pv_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = lower_pv_pressure_.serialize_with_id(static_cast(FieldNumber::LOWER_PV_PRESSURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::IB_PRESSURE: + return_value = ib_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LOWER_PV_PRESSURE: + return_value = lower_pv_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_ib_pressure(); + clear_lower_pv_pressure(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::IB_PRESSURE: + name = IB_PRESSURE_NAME; + break; + case FieldNumber::LOWER_PV_PRESSURE: + name = LOWER_PV_PRESSURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = ib_pressure_.to_string(left_chars, indent_level + 2, IB_PRESSURE_NAME, true); + left_chars = lower_pv_pressure_.to_string(left_chars, indent_level + 2, LOWER_PV_PRESSURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 ib_pressure_ = 0; + EmbeddedProto::int32 lower_pv_pressure_ = 0; + +}; + +class PbbTemperature final: public ::EmbeddedProto::MessageInterface +{ + public: + PbbTemperature() = default; + PbbTemperature(const PbbTemperature& rhs ) + { + set_ib_temperature(rhs.get_ib_temperature()); + set_pv_temperature(rhs.get_pv_temperature()); + } + + PbbTemperature(const PbbTemperature&& rhs ) noexcept + { + set_ib_temperature(rhs.get_ib_temperature()); + set_pv_temperature(rhs.get_pv_temperature()); + } + + ~PbbTemperature() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + IB_TEMPERATURE = 1, + PV_TEMPERATURE = 2 + }; + + PbbTemperature& operator=(const PbbTemperature& rhs) + { + set_ib_temperature(rhs.get_ib_temperature()); + set_pv_temperature(rhs.get_pv_temperature()); + return *this; + } + + PbbTemperature& operator=(const PbbTemperature&& rhs) noexcept + { + set_ib_temperature(rhs.get_ib_temperature()); + set_pv_temperature(rhs.get_pv_temperature()); + return *this; + } + + static constexpr char const* IB_TEMPERATURE_NAME = "ib_temperature"; + inline void clear_ib_temperature() { ib_temperature_.clear(); } + inline void set_ib_temperature(const int32_t& value) { ib_temperature_ = value; } + inline void set_ib_temperature(const int32_t&& value) { ib_temperature_ = value; } + inline int32_t& mutable_ib_temperature() { return ib_temperature_.get(); } + inline const int32_t& get_ib_temperature() const { return ib_temperature_.get(); } + inline int32_t ib_temperature() const { return ib_temperature_.get(); } + + static constexpr char const* PV_TEMPERATURE_NAME = "pv_temperature"; + inline void clear_pv_temperature() { pv_temperature_.clear(); } + inline void set_pv_temperature(const int32_t& value) { pv_temperature_ = value; } + inline void set_pv_temperature(const int32_t&& value) { pv_temperature_ = value; } + inline int32_t& mutable_pv_temperature() { return pv_temperature_.get(); } + inline const int32_t& get_pv_temperature() const { return pv_temperature_.get(); } + inline int32_t pv_temperature() const { return pv_temperature_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != ib_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ib_temperature_.serialize_with_id(static_cast(FieldNumber::IB_TEMPERATURE), buffer, false); + } + + if((0 != pv_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pv_temperature_.serialize_with_id(static_cast(FieldNumber::PV_TEMPERATURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::IB_TEMPERATURE: + return_value = ib_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PV_TEMPERATURE: + return_value = pv_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_ib_temperature(); + clear_pv_temperature(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::IB_TEMPERATURE: + name = IB_TEMPERATURE_NAME; + break; + case FieldNumber::PV_TEMPERATURE: + name = PV_TEMPERATURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = ib_temperature_.to_string(left_chars, indent_level + 2, IB_TEMPERATURE_NAME, true); + left_chars = pv_temperature_.to_string(left_chars, indent_level + 2, PV_TEMPERATURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 ib_temperature_ = 0; + EmbeddedProto::int32 pv_temperature_ = 0; + +}; + +class PressureLog final: public ::EmbeddedProto::MessageInterface +{ + public: + PressureLog() = default; + PressureLog(const PressureLog& rhs ) + { + set_time(rhs.get_time()); + set_pv_pressure(rhs.get_pv_pressure()); + set_ib_pressure(rhs.get_ib_pressure()); + } + + PressureLog(const PressureLog&& rhs ) noexcept + { + set_time(rhs.get_time()); + set_pv_pressure(rhs.get_pv_pressure()); + set_ib_pressure(rhs.get_ib_pressure()); + } + + ~PressureLog() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TIME = 1, + PV_PRESSURE = 2, + IB_PRESSURE = 3 + }; + + PressureLog& operator=(const PressureLog& rhs) + { + set_time(rhs.get_time()); + set_pv_pressure(rhs.get_pv_pressure()); + set_ib_pressure(rhs.get_ib_pressure()); + return *this; + } + + PressureLog& operator=(const PressureLog&& rhs) noexcept + { + set_time(rhs.get_time()); + set_pv_pressure(rhs.get_pv_pressure()); + set_ib_pressure(rhs.get_ib_pressure()); + return *this; + } + + static constexpr char const* TIME_NAME = "time"; + inline void clear_time() { time_.clear(); } + inline void set_time(const uint32_t& value) { time_ = value; } + inline void set_time(const uint32_t&& value) { time_ = value; } + inline uint32_t& mutable_time() { return time_.get(); } + inline const uint32_t& get_time() const { return time_.get(); } + inline uint32_t time() const { return time_.get(); } + + static constexpr char const* PV_PRESSURE_NAME = "pv_pressure"; + inline void clear_pv_pressure() { pv_pressure_.clear(); } + inline void set_pv_pressure(const int32_t& value) { pv_pressure_ = value; } + inline void set_pv_pressure(const int32_t&& value) { pv_pressure_ = value; } + inline int32_t& mutable_pv_pressure() { return pv_pressure_.get(); } + inline const int32_t& get_pv_pressure() const { return pv_pressure_.get(); } + inline int32_t pv_pressure() const { return pv_pressure_.get(); } + + static constexpr char const* IB_PRESSURE_NAME = "ib_pressure"; + inline void clear_ib_pressure() { ib_pressure_.clear(); } + inline void set_ib_pressure(const int32_t& value) { ib_pressure_ = value; } + inline void set_ib_pressure(const int32_t&& value) { ib_pressure_ = value; } + inline int32_t& mutable_ib_pressure() { return ib_pressure_.get(); } + inline const int32_t& get_ib_pressure() const { return ib_pressure_.get(); } + inline int32_t ib_pressure() const { return ib_pressure_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0U != time_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = time_.serialize_with_id(static_cast(FieldNumber::TIME), buffer, false); + } + + if((0 != pv_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pv_pressure_.serialize_with_id(static_cast(FieldNumber::PV_PRESSURE), buffer, false); + } + + if((0 != ib_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ib_pressure_.serialize_with_id(static_cast(FieldNumber::IB_PRESSURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TIME: + return_value = time_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PV_PRESSURE: + return_value = pv_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::IB_PRESSURE: + return_value = ib_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_time(); + clear_pv_pressure(); + clear_ib_pressure(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TIME: + name = TIME_NAME; + break; + case FieldNumber::PV_PRESSURE: + name = PV_PRESSURE_NAME; + break; + case FieldNumber::IB_PRESSURE: + name = IB_PRESSURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = time_.to_string(left_chars, indent_level + 2, TIME_NAME, true); + left_chars = pv_pressure_.to_string(left_chars, indent_level + 2, PV_PRESSURE_NAME, false); + left_chars = ib_pressure_.to_string(left_chars, indent_level + 2, IB_PRESSURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::uint32 time_ = 0U; + EmbeddedProto::int32 pv_pressure_ = 0; + EmbeddedProto::int32 ib_pressure_ = 0; + +}; + +class RcuPressure final: public ::EmbeddedProto::MessageInterface +{ + public: + RcuPressure() = default; + RcuPressure(const RcuPressure& rhs ) + { + set_pt1_pressure(rhs.get_pt1_pressure()); + set_pt2_pressure(rhs.get_pt2_pressure()); + set_pt3_pressure(rhs.get_pt3_pressure()); + set_pt4_pressure(rhs.get_pt4_pressure()); + } + + RcuPressure(const RcuPressure&& rhs ) noexcept + { + set_pt1_pressure(rhs.get_pt1_pressure()); + set_pt2_pressure(rhs.get_pt2_pressure()); + set_pt3_pressure(rhs.get_pt3_pressure()); + set_pt4_pressure(rhs.get_pt4_pressure()); + } + + ~RcuPressure() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + PT1_PRESSURE = 1, + PT2_PRESSURE = 2, + PT3_PRESSURE = 3, + PT4_PRESSURE = 4 + }; + + RcuPressure& operator=(const RcuPressure& rhs) + { + set_pt1_pressure(rhs.get_pt1_pressure()); + set_pt2_pressure(rhs.get_pt2_pressure()); + set_pt3_pressure(rhs.get_pt3_pressure()); + set_pt4_pressure(rhs.get_pt4_pressure()); + return *this; + } + + RcuPressure& operator=(const RcuPressure&& rhs) noexcept + { + set_pt1_pressure(rhs.get_pt1_pressure()); + set_pt2_pressure(rhs.get_pt2_pressure()); + set_pt3_pressure(rhs.get_pt3_pressure()); + set_pt4_pressure(rhs.get_pt4_pressure()); + return *this; + } + + static constexpr char const* PT1_PRESSURE_NAME = "pt1_pressure"; + inline void clear_pt1_pressure() { pt1_pressure_.clear(); } + inline void set_pt1_pressure(const int32_t& value) { pt1_pressure_ = value; } + inline void set_pt1_pressure(const int32_t&& value) { pt1_pressure_ = value; } + inline int32_t& mutable_pt1_pressure() { return pt1_pressure_.get(); } + inline const int32_t& get_pt1_pressure() const { return pt1_pressure_.get(); } + inline int32_t pt1_pressure() const { return pt1_pressure_.get(); } + + static constexpr char const* PT2_PRESSURE_NAME = "pt2_pressure"; + inline void clear_pt2_pressure() { pt2_pressure_.clear(); } + inline void set_pt2_pressure(const int32_t& value) { pt2_pressure_ = value; } + inline void set_pt2_pressure(const int32_t&& value) { pt2_pressure_ = value; } + inline int32_t& mutable_pt2_pressure() { return pt2_pressure_.get(); } + inline const int32_t& get_pt2_pressure() const { return pt2_pressure_.get(); } + inline int32_t pt2_pressure() const { return pt2_pressure_.get(); } + + static constexpr char const* PT3_PRESSURE_NAME = "pt3_pressure"; + inline void clear_pt3_pressure() { pt3_pressure_.clear(); } + inline void set_pt3_pressure(const int32_t& value) { pt3_pressure_ = value; } + inline void set_pt3_pressure(const int32_t&& value) { pt3_pressure_ = value; } + inline int32_t& mutable_pt3_pressure() { return pt3_pressure_.get(); } + inline const int32_t& get_pt3_pressure() const { return pt3_pressure_.get(); } + inline int32_t pt3_pressure() const { return pt3_pressure_.get(); } + + static constexpr char const* PT4_PRESSURE_NAME = "pt4_pressure"; + inline void clear_pt4_pressure() { pt4_pressure_.clear(); } + inline void set_pt4_pressure(const int32_t& value) { pt4_pressure_ = value; } + inline void set_pt4_pressure(const int32_t&& value) { pt4_pressure_ = value; } + inline int32_t& mutable_pt4_pressure() { return pt4_pressure_.get(); } + inline const int32_t& get_pt4_pressure() const { return pt4_pressure_.get(); } + inline int32_t pt4_pressure() const { return pt4_pressure_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != pt1_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pt1_pressure_.serialize_with_id(static_cast(FieldNumber::PT1_PRESSURE), buffer, false); + } + + if((0 != pt2_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pt2_pressure_.serialize_with_id(static_cast(FieldNumber::PT2_PRESSURE), buffer, false); + } + + if((0 != pt3_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pt3_pressure_.serialize_with_id(static_cast(FieldNumber::PT3_PRESSURE), buffer, false); + } + + if((0 != pt4_pressure_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pt4_pressure_.serialize_with_id(static_cast(FieldNumber::PT4_PRESSURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::PT1_PRESSURE: + return_value = pt1_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PT2_PRESSURE: + return_value = pt2_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PT3_PRESSURE: + return_value = pt3_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PT4_PRESSURE: + return_value = pt4_pressure_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_pt1_pressure(); + clear_pt2_pressure(); + clear_pt3_pressure(); + clear_pt4_pressure(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::PT1_PRESSURE: + name = PT1_PRESSURE_NAME; + break; + case FieldNumber::PT2_PRESSURE: + name = PT2_PRESSURE_NAME; + break; + case FieldNumber::PT3_PRESSURE: + name = PT3_PRESSURE_NAME; + break; + case FieldNumber::PT4_PRESSURE: + name = PT4_PRESSURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = pt1_pressure_.to_string(left_chars, indent_level + 2, PT1_PRESSURE_NAME, true); + left_chars = pt2_pressure_.to_string(left_chars, indent_level + 2, PT2_PRESSURE_NAME, false); + left_chars = pt3_pressure_.to_string(left_chars, indent_level + 2, PT3_PRESSURE_NAME, false); + left_chars = pt4_pressure_.to_string(left_chars, indent_level + 2, PT4_PRESSURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 pt1_pressure_ = 0; + EmbeddedProto::int32 pt2_pressure_ = 0; + EmbeddedProto::int32 pt3_pressure_ = 0; + EmbeddedProto::int32 pt4_pressure_ = 0; + +}; + +class RcuTemperature final: public ::EmbeddedProto::MessageInterface +{ + public: + RcuTemperature() = default; + RcuTemperature(const RcuTemperature& rhs ) + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + } + + RcuTemperature(const RcuTemperature&& rhs ) noexcept + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + } + + ~RcuTemperature() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TC1_TEMPERATURE = 1, + TC2_TEMPERATURE = 2 + }; + + RcuTemperature& operator=(const RcuTemperature& rhs) + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + return *this; + } + + RcuTemperature& operator=(const RcuTemperature&& rhs) noexcept + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + return *this; + } + + static constexpr char const* TC1_TEMPERATURE_NAME = "tc1_temperature"; + inline void clear_tc1_temperature() { tc1_temperature_.clear(); } + inline void set_tc1_temperature(const int32_t& value) { tc1_temperature_ = value; } + inline void set_tc1_temperature(const int32_t&& value) { tc1_temperature_ = value; } + inline int32_t& mutable_tc1_temperature() { return tc1_temperature_.get(); } + inline const int32_t& get_tc1_temperature() const { return tc1_temperature_.get(); } + inline int32_t tc1_temperature() const { return tc1_temperature_.get(); } + + static constexpr char const* TC2_TEMPERATURE_NAME = "tc2_temperature"; + inline void clear_tc2_temperature() { tc2_temperature_.clear(); } + inline void set_tc2_temperature(const int32_t& value) { tc2_temperature_ = value; } + inline void set_tc2_temperature(const int32_t&& value) { tc2_temperature_ = value; } + inline int32_t& mutable_tc2_temperature() { return tc2_temperature_.get(); } + inline const int32_t& get_tc2_temperature() const { return tc2_temperature_.get(); } + inline int32_t tc2_temperature() const { return tc2_temperature_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != tc1_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = tc1_temperature_.serialize_with_id(static_cast(FieldNumber::TC1_TEMPERATURE), buffer, false); + } + + if((0 != tc2_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = tc2_temperature_.serialize_with_id(static_cast(FieldNumber::TC2_TEMPERATURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TC1_TEMPERATURE: + return_value = tc1_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TC2_TEMPERATURE: + return_value = tc2_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_tc1_temperature(); + clear_tc2_temperature(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TC1_TEMPERATURE: + name = TC1_TEMPERATURE_NAME; + break; + case FieldNumber::TC2_TEMPERATURE: + name = TC2_TEMPERATURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = tc1_temperature_.to_string(left_chars, indent_level + 2, TC1_TEMPERATURE_NAME, true); + left_chars = tc2_temperature_.to_string(left_chars, indent_level + 2, TC2_TEMPERATURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 tc1_temperature_ = 0; + EmbeddedProto::int32 tc2_temperature_ = 0; + +}; + +class RelayStatus final: public ::EmbeddedProto::MessageInterface +{ + public: + RelayStatus() = default; + RelayStatus(const RelayStatus& rhs ) + { + set_ac1_open(rhs.get_ac1_open()); + set_ac2_open(rhs.get_ac2_open()); + set_pbv1_open(rhs.get_pbv1_open()); + set_pbv2_open(rhs.get_pbv2_open()); + set_pbv3_open(rhs.get_pbv3_open()); + set_pbv4_open(rhs.get_pbv4_open()); + set_sol5_open(rhs.get_sol5_open()); + set_sol6_open(rhs.get_sol6_open()); + set_sol7_open(rhs.get_sol7_open()); + set_sol8a_open(rhs.get_sol8a_open()); + set_sol8b_open(rhs.get_sol8b_open()); + } + + RelayStatus(const RelayStatus&& rhs ) noexcept + { + set_ac1_open(rhs.get_ac1_open()); + set_ac2_open(rhs.get_ac2_open()); + set_pbv1_open(rhs.get_pbv1_open()); + set_pbv2_open(rhs.get_pbv2_open()); + set_pbv3_open(rhs.get_pbv3_open()); + set_pbv4_open(rhs.get_pbv4_open()); + set_sol5_open(rhs.get_sol5_open()); + set_sol6_open(rhs.get_sol6_open()); + set_sol7_open(rhs.get_sol7_open()); + set_sol8a_open(rhs.get_sol8a_open()); + set_sol8b_open(rhs.get_sol8b_open()); + } + + ~RelayStatus() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + AC1_OPEN = 1, + AC2_OPEN = 2, + PBV1_OPEN = 3, + PBV2_OPEN = 4, + PBV3_OPEN = 5, + PBV4_OPEN = 6, + SOL5_OPEN = 10, + SOL6_OPEN = 11, + SOL7_OPEN = 12, + SOL8A_OPEN = 13, + SOL8B_OPEN = 14 + }; + + RelayStatus& operator=(const RelayStatus& rhs) + { + set_ac1_open(rhs.get_ac1_open()); + set_ac2_open(rhs.get_ac2_open()); + set_pbv1_open(rhs.get_pbv1_open()); + set_pbv2_open(rhs.get_pbv2_open()); + set_pbv3_open(rhs.get_pbv3_open()); + set_pbv4_open(rhs.get_pbv4_open()); + set_sol5_open(rhs.get_sol5_open()); + set_sol6_open(rhs.get_sol6_open()); + set_sol7_open(rhs.get_sol7_open()); + set_sol8a_open(rhs.get_sol8a_open()); + set_sol8b_open(rhs.get_sol8b_open()); + return *this; + } + + RelayStatus& operator=(const RelayStatus&& rhs) noexcept + { + set_ac1_open(rhs.get_ac1_open()); + set_ac2_open(rhs.get_ac2_open()); + set_pbv1_open(rhs.get_pbv1_open()); + set_pbv2_open(rhs.get_pbv2_open()); + set_pbv3_open(rhs.get_pbv3_open()); + set_pbv4_open(rhs.get_pbv4_open()); + set_sol5_open(rhs.get_sol5_open()); + set_sol6_open(rhs.get_sol6_open()); + set_sol7_open(rhs.get_sol7_open()); + set_sol8a_open(rhs.get_sol8a_open()); + set_sol8b_open(rhs.get_sol8b_open()); + return *this; + } + + static constexpr char const* AC1_OPEN_NAME = "ac1_open"; + inline void clear_ac1_open() { ac1_open_.clear(); } + inline void set_ac1_open(const bool& value) { ac1_open_ = value; } + inline void set_ac1_open(const bool&& value) { ac1_open_ = value; } + inline bool& mutable_ac1_open() { return ac1_open_.get(); } + inline const bool& get_ac1_open() const { return ac1_open_.get(); } + inline bool ac1_open() const { return ac1_open_.get(); } + + static constexpr char const* AC2_OPEN_NAME = "ac2_open"; + inline void clear_ac2_open() { ac2_open_.clear(); } + inline void set_ac2_open(const bool& value) { ac2_open_ = value; } + inline void set_ac2_open(const bool&& value) { ac2_open_ = value; } + inline bool& mutable_ac2_open() { return ac2_open_.get(); } + inline const bool& get_ac2_open() const { return ac2_open_.get(); } + inline bool ac2_open() const { return ac2_open_.get(); } + + static constexpr char const* PBV1_OPEN_NAME = "pbv1_open"; + inline void clear_pbv1_open() { pbv1_open_.clear(); } + inline void set_pbv1_open(const bool& value) { pbv1_open_ = value; } + inline void set_pbv1_open(const bool&& value) { pbv1_open_ = value; } + inline bool& mutable_pbv1_open() { return pbv1_open_.get(); } + inline const bool& get_pbv1_open() const { return pbv1_open_.get(); } + inline bool pbv1_open() const { return pbv1_open_.get(); } + + static constexpr char const* PBV2_OPEN_NAME = "pbv2_open"; + inline void clear_pbv2_open() { pbv2_open_.clear(); } + inline void set_pbv2_open(const bool& value) { pbv2_open_ = value; } + inline void set_pbv2_open(const bool&& value) { pbv2_open_ = value; } + inline bool& mutable_pbv2_open() { return pbv2_open_.get(); } + inline const bool& get_pbv2_open() const { return pbv2_open_.get(); } + inline bool pbv2_open() const { return pbv2_open_.get(); } + + static constexpr char const* PBV3_OPEN_NAME = "pbv3_open"; + inline void clear_pbv3_open() { pbv3_open_.clear(); } + inline void set_pbv3_open(const bool& value) { pbv3_open_ = value; } + inline void set_pbv3_open(const bool&& value) { pbv3_open_ = value; } + inline bool& mutable_pbv3_open() { return pbv3_open_.get(); } + inline const bool& get_pbv3_open() const { return pbv3_open_.get(); } + inline bool pbv3_open() const { return pbv3_open_.get(); } + + static constexpr char const* PBV4_OPEN_NAME = "pbv4_open"; + inline void clear_pbv4_open() { pbv4_open_.clear(); } + inline void set_pbv4_open(const bool& value) { pbv4_open_ = value; } + inline void set_pbv4_open(const bool&& value) { pbv4_open_ = value; } + inline bool& mutable_pbv4_open() { return pbv4_open_.get(); } + inline const bool& get_pbv4_open() const { return pbv4_open_.get(); } + inline bool pbv4_open() const { return pbv4_open_.get(); } + + static constexpr char const* SOL5_OPEN_NAME = "sol5_open"; + inline void clear_sol5_open() { sol5_open_.clear(); } + inline void set_sol5_open(const bool& value) { sol5_open_ = value; } + inline void set_sol5_open(const bool&& value) { sol5_open_ = value; } + inline bool& mutable_sol5_open() { return sol5_open_.get(); } + inline const bool& get_sol5_open() const { return sol5_open_.get(); } + inline bool sol5_open() const { return sol5_open_.get(); } + + static constexpr char const* SOL6_OPEN_NAME = "sol6_open"; + inline void clear_sol6_open() { sol6_open_.clear(); } + inline void set_sol6_open(const bool& value) { sol6_open_ = value; } + inline void set_sol6_open(const bool&& value) { sol6_open_ = value; } + inline bool& mutable_sol6_open() { return sol6_open_.get(); } + inline const bool& get_sol6_open() const { return sol6_open_.get(); } + inline bool sol6_open() const { return sol6_open_.get(); } + + static constexpr char const* SOL7_OPEN_NAME = "sol7_open"; + inline void clear_sol7_open() { sol7_open_.clear(); } + inline void set_sol7_open(const bool& value) { sol7_open_ = value; } + inline void set_sol7_open(const bool&& value) { sol7_open_ = value; } + inline bool& mutable_sol7_open() { return sol7_open_.get(); } + inline const bool& get_sol7_open() const { return sol7_open_.get(); } + inline bool sol7_open() const { return sol7_open_.get(); } + + static constexpr char const* SOL8A_OPEN_NAME = "sol8a_open"; + inline void clear_sol8a_open() { sol8a_open_.clear(); } + inline void set_sol8a_open(const bool& value) { sol8a_open_ = value; } + inline void set_sol8a_open(const bool&& value) { sol8a_open_ = value; } + inline bool& mutable_sol8a_open() { return sol8a_open_.get(); } + inline const bool& get_sol8a_open() const { return sol8a_open_.get(); } + inline bool sol8a_open() const { return sol8a_open_.get(); } + + static constexpr char const* SOL8B_OPEN_NAME = "sol8b_open"; + inline void clear_sol8b_open() { sol8b_open_.clear(); } + inline void set_sol8b_open(const bool& value) { sol8b_open_ = value; } + inline void set_sol8b_open(const bool&& value) { sol8b_open_ = value; } + inline bool& mutable_sol8b_open() { return sol8b_open_.get(); } + inline const bool& get_sol8b_open() const { return sol8b_open_.get(); } + inline bool sol8b_open() const { return sol8b_open_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((false != ac1_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ac1_open_.serialize_with_id(static_cast(FieldNumber::AC1_OPEN), buffer, false); + } + + if((false != ac2_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = ac2_open_.serialize_with_id(static_cast(FieldNumber::AC2_OPEN), buffer, false); + } + + if((false != pbv1_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pbv1_open_.serialize_with_id(static_cast(FieldNumber::PBV1_OPEN), buffer, false); + } + + if((false != pbv2_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pbv2_open_.serialize_with_id(static_cast(FieldNumber::PBV2_OPEN), buffer, false); + } + + if((false != pbv3_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pbv3_open_.serialize_with_id(static_cast(FieldNumber::PBV3_OPEN), buffer, false); + } + + if((false != pbv4_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = pbv4_open_.serialize_with_id(static_cast(FieldNumber::PBV4_OPEN), buffer, false); + } + + if((false != sol5_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sol5_open_.serialize_with_id(static_cast(FieldNumber::SOL5_OPEN), buffer, false); + } + + if((false != sol6_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sol6_open_.serialize_with_id(static_cast(FieldNumber::SOL6_OPEN), buffer, false); + } + + if((false != sol7_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sol7_open_.serialize_with_id(static_cast(FieldNumber::SOL7_OPEN), buffer, false); + } + + if((false != sol8a_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sol8a_open_.serialize_with_id(static_cast(FieldNumber::SOL8A_OPEN), buffer, false); + } + + if((false != sol8b_open_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = sol8b_open_.serialize_with_id(static_cast(FieldNumber::SOL8B_OPEN), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::AC1_OPEN: + return_value = ac1_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::AC2_OPEN: + return_value = ac2_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PBV1_OPEN: + return_value = pbv1_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PBV2_OPEN: + return_value = pbv2_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PBV3_OPEN: + return_value = pbv3_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::PBV4_OPEN: + return_value = pbv4_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOL5_OPEN: + return_value = sol5_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOL6_OPEN: + return_value = sol6_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOL7_OPEN: + return_value = sol7_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOL8A_OPEN: + return_value = sol8a_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::SOL8B_OPEN: + return_value = sol8b_open_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_ac1_open(); + clear_ac2_open(); + clear_pbv1_open(); + clear_pbv2_open(); + clear_pbv3_open(); + clear_pbv4_open(); + clear_sol5_open(); + clear_sol6_open(); + clear_sol7_open(); + clear_sol8a_open(); + clear_sol8b_open(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::AC1_OPEN: + name = AC1_OPEN_NAME; + break; + case FieldNumber::AC2_OPEN: + name = AC2_OPEN_NAME; + break; + case FieldNumber::PBV1_OPEN: + name = PBV1_OPEN_NAME; + break; + case FieldNumber::PBV2_OPEN: + name = PBV2_OPEN_NAME; + break; + case FieldNumber::PBV3_OPEN: + name = PBV3_OPEN_NAME; + break; + case FieldNumber::PBV4_OPEN: + name = PBV4_OPEN_NAME; + break; + case FieldNumber::SOL5_OPEN: + name = SOL5_OPEN_NAME; + break; + case FieldNumber::SOL6_OPEN: + name = SOL6_OPEN_NAME; + break; + case FieldNumber::SOL7_OPEN: + name = SOL7_OPEN_NAME; + break; + case FieldNumber::SOL8A_OPEN: + name = SOL8A_OPEN_NAME; + break; + case FieldNumber::SOL8B_OPEN: + name = SOL8B_OPEN_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = ac1_open_.to_string(left_chars, indent_level + 2, AC1_OPEN_NAME, true); + left_chars = ac2_open_.to_string(left_chars, indent_level + 2, AC2_OPEN_NAME, false); + left_chars = pbv1_open_.to_string(left_chars, indent_level + 2, PBV1_OPEN_NAME, false); + left_chars = pbv2_open_.to_string(left_chars, indent_level + 2, PBV2_OPEN_NAME, false); + left_chars = pbv3_open_.to_string(left_chars, indent_level + 2, PBV3_OPEN_NAME, false); + left_chars = pbv4_open_.to_string(left_chars, indent_level + 2, PBV4_OPEN_NAME, false); + left_chars = sol5_open_.to_string(left_chars, indent_level + 2, SOL5_OPEN_NAME, false); + left_chars = sol6_open_.to_string(left_chars, indent_level + 2, SOL6_OPEN_NAME, false); + left_chars = sol7_open_.to_string(left_chars, indent_level + 2, SOL7_OPEN_NAME, false); + left_chars = sol8a_open_.to_string(left_chars, indent_level + 2, SOL8A_OPEN_NAME, false); + left_chars = sol8b_open_.to_string(left_chars, indent_level + 2, SOL8B_OPEN_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::boolean ac1_open_ = false; + EmbeddedProto::boolean ac2_open_ = false; + EmbeddedProto::boolean pbv1_open_ = false; + EmbeddedProto::boolean pbv2_open_ = false; + EmbeddedProto::boolean pbv3_open_ = false; + EmbeddedProto::boolean pbv4_open_ = false; + EmbeddedProto::boolean sol5_open_ = false; + EmbeddedProto::boolean sol6_open_ = false; + EmbeddedProto::boolean sol7_open_ = false; + EmbeddedProto::boolean sol8a_open_ = false; + EmbeddedProto::boolean sol8b_open_ = false; + +}; + +class SobTemperature final: public ::EmbeddedProto::MessageInterface +{ + public: + SobTemperature() = default; + SobTemperature(const SobTemperature& rhs ) + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + } + + SobTemperature(const SobTemperature&& rhs ) noexcept + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + } + + ~SobTemperature() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + TC1_TEMPERATURE = 1, + TC2_TEMPERATURE = 2 + }; + + SobTemperature& operator=(const SobTemperature& rhs) + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + return *this; + } + + SobTemperature& operator=(const SobTemperature&& rhs) noexcept + { + set_tc1_temperature(rhs.get_tc1_temperature()); + set_tc2_temperature(rhs.get_tc2_temperature()); + return *this; + } + + static constexpr char const* TC1_TEMPERATURE_NAME = "tc1_temperature"; + inline void clear_tc1_temperature() { tc1_temperature_.clear(); } + inline void set_tc1_temperature(const int32_t& value) { tc1_temperature_ = value; } + inline void set_tc1_temperature(const int32_t&& value) { tc1_temperature_ = value; } + inline int32_t& mutable_tc1_temperature() { return tc1_temperature_.get(); } + inline const int32_t& get_tc1_temperature() const { return tc1_temperature_.get(); } + inline int32_t tc1_temperature() const { return tc1_temperature_.get(); } + + static constexpr char const* TC2_TEMPERATURE_NAME = "tc2_temperature"; + inline void clear_tc2_temperature() { tc2_temperature_.clear(); } + inline void set_tc2_temperature(const int32_t& value) { tc2_temperature_ = value; } + inline void set_tc2_temperature(const int32_t&& value) { tc2_temperature_ = value; } + inline int32_t& mutable_tc2_temperature() { return tc2_temperature_.get(); } + inline const int32_t& get_tc2_temperature() const { return tc2_temperature_.get(); } + inline int32_t tc2_temperature() const { return tc2_temperature_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((0 != tc1_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = tc1_temperature_.serialize_with_id(static_cast(FieldNumber::TC1_TEMPERATURE), buffer, false); + } + + if((0 != tc2_temperature_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = tc2_temperature_.serialize_with_id(static_cast(FieldNumber::TC2_TEMPERATURE), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::TC1_TEMPERATURE: + return_value = tc1_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TC2_TEMPERATURE: + return_value = tc2_temperature_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_tc1_temperature(); + clear_tc2_temperature(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::TC1_TEMPERATURE: + name = TC1_TEMPERATURE_NAME; + break; + case FieldNumber::TC2_TEMPERATURE: + name = TC2_TEMPERATURE_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = tc1_temperature_.to_string(left_chars, indent_level + 2, TC1_TEMPERATURE_NAME, true); + left_chars = tc2_temperature_.to_string(left_chars, indent_level + 2, TC2_TEMPERATURE_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::int32 tc1_temperature_ = 0; + EmbeddedProto::int32 tc2_temperature_ = 0; + +}; + +class Gps final: public ::EmbeddedProto::MessageInterface +{ + public: + Gps() = default; + Gps(const Gps& rhs ) + { + set_latitude(rhs.get_latitude()); + set_longitude(rhs.get_longitude()); + set_antenna_altitude(rhs.get_antenna_altitude()); + set_geo_id_altitude(rhs.get_geo_id_altitude()); + set_total_altitude(rhs.get_total_altitude()); + set_time(rhs.get_time()); + } + + Gps(const Gps&& rhs ) noexcept + { + set_latitude(rhs.get_latitude()); + set_longitude(rhs.get_longitude()); + set_antenna_altitude(rhs.get_antenna_altitude()); + set_geo_id_altitude(rhs.get_geo_id_altitude()); + set_total_altitude(rhs.get_total_altitude()); + set_time(rhs.get_time()); + } + + ~Gps() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + LATITUDE = 1, + LONGITUDE = 2, + ANTENNA_ALTITUDE = 3, + GEO_ID_ALTITUDE = 4, + TOTAL_ALTITUDE = 5, + TIME = 6 + }; + + Gps& operator=(const Gps& rhs) + { + set_latitude(rhs.get_latitude()); + set_longitude(rhs.get_longitude()); + set_antenna_altitude(rhs.get_antenna_altitude()); + set_geo_id_altitude(rhs.get_geo_id_altitude()); + set_total_altitude(rhs.get_total_altitude()); + set_time(rhs.get_time()); + return *this; + } + + Gps& operator=(const Gps&& rhs) noexcept + { + set_latitude(rhs.get_latitude()); + set_longitude(rhs.get_longitude()); + set_antenna_altitude(rhs.get_antenna_altitude()); + set_geo_id_altitude(rhs.get_geo_id_altitude()); + set_total_altitude(rhs.get_total_altitude()); + set_time(rhs.get_time()); + return *this; + } + + static constexpr char const* LATITUDE_NAME = "latitude"; + inline void clear_latitude() { latitude_.clear(); } + inline void set_latitude(const CoordinateType& value) { latitude_ = value; } + inline void set_latitude(const CoordinateType&& value) { latitude_ = value; } + inline CoordinateType& mutable_latitude() { return latitude_; } + inline const CoordinateType& get_latitude() const { return latitude_; } + inline const CoordinateType& latitude() const { return latitude_; } + + static constexpr char const* LONGITUDE_NAME = "longitude"; + inline void clear_longitude() { longitude_.clear(); } + inline void set_longitude(const CoordinateType& value) { longitude_ = value; } + inline void set_longitude(const CoordinateType&& value) { longitude_ = value; } + inline CoordinateType& mutable_longitude() { return longitude_; } + inline const CoordinateType& get_longitude() const { return longitude_; } + inline const CoordinateType& longitude() const { return longitude_; } + + static constexpr char const* ANTENNA_ALTITUDE_NAME = "antenna_altitude"; + inline void clear_antenna_altitude() { antenna_altitude_.clear(); } + inline void set_antenna_altitude(const AltitudeType& value) { antenna_altitude_ = value; } + inline void set_antenna_altitude(const AltitudeType&& value) { antenna_altitude_ = value; } + inline AltitudeType& mutable_antenna_altitude() { return antenna_altitude_; } + inline const AltitudeType& get_antenna_altitude() const { return antenna_altitude_; } + inline const AltitudeType& antenna_altitude() const { return antenna_altitude_; } + + static constexpr char const* GEO_ID_ALTITUDE_NAME = "geo_id_altitude"; + inline void clear_geo_id_altitude() { geo_id_altitude_.clear(); } + inline void set_geo_id_altitude(const AltitudeType& value) { geo_id_altitude_ = value; } + inline void set_geo_id_altitude(const AltitudeType&& value) { geo_id_altitude_ = value; } + inline AltitudeType& mutable_geo_id_altitude() { return geo_id_altitude_; } + inline const AltitudeType& get_geo_id_altitude() const { return geo_id_altitude_; } + inline const AltitudeType& geo_id_altitude() const { return geo_id_altitude_; } + + static constexpr char const* TOTAL_ALTITUDE_NAME = "total_altitude"; + inline void clear_total_altitude() { total_altitude_.clear(); } + inline void set_total_altitude(const AltitudeType& value) { total_altitude_ = value; } + inline void set_total_altitude(const AltitudeType&& value) { total_altitude_ = value; } + inline AltitudeType& mutable_total_altitude() { return total_altitude_; } + inline const AltitudeType& get_total_altitude() const { return total_altitude_; } + inline const AltitudeType& total_altitude() const { return total_altitude_; } + + static constexpr char const* TIME_NAME = "time"; + inline void clear_time() { time_.clear(); } + inline void set_time(const uint32_t& value) { time_ = value; } + inline void set_time(const uint32_t&& value) { time_ = value; } + inline uint32_t& mutable_time() { return time_.get(); } + inline const uint32_t& get_time() const { return time_.get(); } + inline uint32_t time() const { return time_.get(); } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = latitude_.serialize_with_id(static_cast(FieldNumber::LATITUDE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = longitude_.serialize_with_id(static_cast(FieldNumber::LONGITUDE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = antenna_altitude_.serialize_with_id(static_cast(FieldNumber::ANTENNA_ALTITUDE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = geo_id_altitude_.serialize_with_id(static_cast(FieldNumber::GEO_ID_ALTITUDE), buffer, false); + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + return_value = total_altitude_.serialize_with_id(static_cast(FieldNumber::TOTAL_ALTITUDE), buffer, false); + } + + if((0U != time_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = time_.serialize_with_id(static_cast(FieldNumber::TIME), buffer, false); + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::LATITUDE: + return_value = latitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::LONGITUDE: + return_value = longitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::ANTENNA_ALTITUDE: + return_value = antenna_altitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GEO_ID_ALTITUDE: + return_value = geo_id_altitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TOTAL_ALTITUDE: + return_value = total_altitude_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TIME: + return_value = time_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_latitude(); + clear_longitude(); + clear_antenna_altitude(); + clear_geo_id_altitude(); + clear_total_altitude(); + clear_time(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::LATITUDE: + name = LATITUDE_NAME; + break; + case FieldNumber::LONGITUDE: + name = LONGITUDE_NAME; + break; + case FieldNumber::ANTENNA_ALTITUDE: + name = ANTENNA_ALTITUDE_NAME; + break; + case FieldNumber::GEO_ID_ALTITUDE: + name = GEO_ID_ALTITUDE_NAME; + break; + case FieldNumber::TOTAL_ALTITUDE: + name = TOTAL_ALTITUDE_NAME; + break; + case FieldNumber::TIME: + name = TIME_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = latitude_.to_string(left_chars, indent_level + 2, LATITUDE_NAME, true); + left_chars = longitude_.to_string(left_chars, indent_level + 2, LONGITUDE_NAME, false); + left_chars = antenna_altitude_.to_string(left_chars, indent_level + 2, ANTENNA_ALTITUDE_NAME, false); + left_chars = geo_id_altitude_.to_string(left_chars, indent_level + 2, GEO_ID_ALTITUDE_NAME, false); + left_chars = total_altitude_.to_string(left_chars, indent_level + 2, TOTAL_ALTITUDE_NAME, false); + left_chars = time_.to_string(left_chars, indent_level + 2, TIME_NAME, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + CoordinateType latitude_; + CoordinateType longitude_; + AltitudeType antenna_altitude_; + AltitudeType geo_id_altitude_; + AltitudeType total_altitude_; + EmbeddedProto::uint32 time_ = 0U; + +}; + +class TelemetryMessage final: public ::EmbeddedProto::MessageInterface +{ + public: + TelemetryMessage() = default; + TelemetryMessage(const TelemetryMessage& rhs ) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::GPS: + set_gps(rhs.get_gps()); + break; + + case FieldNumber::BARO: + set_baro(rhs.get_baro()); + break; + + case FieldNumber::IMU: + set_imu(rhs.get_imu()); + break; + + case FieldNumber::BATTERY: + set_battery(rhs.get_battery()); + break; + + case FieldNumber::FLASHSTATE: + set_flashState(rhs.get_flashState()); + break; + + case FieldNumber::DMBPRESSURE: + set_dmbPressure(rhs.get_dmbPressure()); + break; + + case FieldNumber::PBBPRESSURE: + set_pbbPressure(rhs.get_pbbPressure()); + break; + + case FieldNumber::PBBTEMPERATURE: + set_pbbTemperature(rhs.get_pbbTemperature()); + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + set_combustionControlStatus(rhs.get_combustionControlStatus()); + break; + + case FieldNumber::RCUPRESSURE: + set_rcuPressure(rhs.get_rcuPressure()); + break; + + case FieldNumber::RCUTEMPERATURE: + set_rcuTemperature(rhs.get_rcuTemperature()); + break; + + case FieldNumber::NOSLOADCELL: + set_nosLoadCell(rhs.get_nosLoadCell()); + break; + + case FieldNumber::RELAYSTATUS: + set_relayStatus(rhs.get_relayStatus()); + break; + + case FieldNumber::PADBOXSTATUS: + set_padBoxStatus(rhs.get_padBoxStatus()); + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + set_launchRailLoadCell(rhs.get_launchRailLoadCell()); + break; + + case FieldNumber::SOBTEMPERATURE: + set_sobTemperature(rhs.get_sobTemperature()); + break; + + case FieldNumber::PRESSURELOG: + set_pressureLog(rhs.get_pressureLog()); + break; + + default: + break; + } + + } + + TelemetryMessage(const TelemetryMessage&& rhs ) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::GPS: + set_gps(rhs.get_gps()); + break; + + case FieldNumber::BARO: + set_baro(rhs.get_baro()); + break; + + case FieldNumber::IMU: + set_imu(rhs.get_imu()); + break; + + case FieldNumber::BATTERY: + set_battery(rhs.get_battery()); + break; + + case FieldNumber::FLASHSTATE: + set_flashState(rhs.get_flashState()); + break; + + case FieldNumber::DMBPRESSURE: + set_dmbPressure(rhs.get_dmbPressure()); + break; + + case FieldNumber::PBBPRESSURE: + set_pbbPressure(rhs.get_pbbPressure()); + break; + + case FieldNumber::PBBTEMPERATURE: + set_pbbTemperature(rhs.get_pbbTemperature()); + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + set_combustionControlStatus(rhs.get_combustionControlStatus()); + break; + + case FieldNumber::RCUPRESSURE: + set_rcuPressure(rhs.get_rcuPressure()); + break; + + case FieldNumber::RCUTEMPERATURE: + set_rcuTemperature(rhs.get_rcuTemperature()); + break; + + case FieldNumber::NOSLOADCELL: + set_nosLoadCell(rhs.get_nosLoadCell()); + break; + + case FieldNumber::RELAYSTATUS: + set_relayStatus(rhs.get_relayStatus()); + break; + + case FieldNumber::PADBOXSTATUS: + set_padBoxStatus(rhs.get_padBoxStatus()); + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + set_launchRailLoadCell(rhs.get_launchRailLoadCell()); + break; + + case FieldNumber::SOBTEMPERATURE: + set_sobTemperature(rhs.get_sobTemperature()); + break; + + case FieldNumber::PRESSURELOG: + set_pressureLog(rhs.get_pressureLog()); + break; + + default: + break; + } + + } + + ~TelemetryMessage() override = default; + + enum class FieldNumber : uint32_t + { + NOT_SET = 0, + SOURCE = 1, + TARGET = 2, + GPS = 3, + BARO = 4, + IMU = 5, + BATTERY = 6, + FLASHSTATE = 7, + DMBPRESSURE = 8, + PBBPRESSURE = 9, + PBBTEMPERATURE = 10, + COMBUSTIONCONTROLSTATUS = 11, + RCUPRESSURE = 12, + RCUTEMPERATURE = 13, + NOSLOADCELL = 14, + RELAYSTATUS = 15, + PADBOXSTATUS = 16, + LAUNCHRAILLOADCELL = 17, + SOBTEMPERATURE = 18, + PRESSURELOG = 19 + }; + + TelemetryMessage& operator=(const TelemetryMessage& rhs) + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::GPS: + set_gps(rhs.get_gps()); + break; + + case FieldNumber::BARO: + set_baro(rhs.get_baro()); + break; + + case FieldNumber::IMU: + set_imu(rhs.get_imu()); + break; + + case FieldNumber::BATTERY: + set_battery(rhs.get_battery()); + break; + + case FieldNumber::FLASHSTATE: + set_flashState(rhs.get_flashState()); + break; + + case FieldNumber::DMBPRESSURE: + set_dmbPressure(rhs.get_dmbPressure()); + break; + + case FieldNumber::PBBPRESSURE: + set_pbbPressure(rhs.get_pbbPressure()); + break; + + case FieldNumber::PBBTEMPERATURE: + set_pbbTemperature(rhs.get_pbbTemperature()); + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + set_combustionControlStatus(rhs.get_combustionControlStatus()); + break; + + case FieldNumber::RCUPRESSURE: + set_rcuPressure(rhs.get_rcuPressure()); + break; + + case FieldNumber::RCUTEMPERATURE: + set_rcuTemperature(rhs.get_rcuTemperature()); + break; + + case FieldNumber::NOSLOADCELL: + set_nosLoadCell(rhs.get_nosLoadCell()); + break; + + case FieldNumber::RELAYSTATUS: + set_relayStatus(rhs.get_relayStatus()); + break; + + case FieldNumber::PADBOXSTATUS: + set_padBoxStatus(rhs.get_padBoxStatus()); + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + set_launchRailLoadCell(rhs.get_launchRailLoadCell()); + break; + + case FieldNumber::SOBTEMPERATURE: + set_sobTemperature(rhs.get_sobTemperature()); + break; + + case FieldNumber::PRESSURELOG: + set_pressureLog(rhs.get_pressureLog()); + break; + + default: + break; + } + + return *this; + } + + TelemetryMessage& operator=(const TelemetryMessage&& rhs) noexcept + { + set_source(rhs.get_source()); + set_target(rhs.get_target()); + if(rhs.get_which_message() != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + switch(rhs.get_which_message()) + { + case FieldNumber::GPS: + set_gps(rhs.get_gps()); + break; + + case FieldNumber::BARO: + set_baro(rhs.get_baro()); + break; + + case FieldNumber::IMU: + set_imu(rhs.get_imu()); + break; + + case FieldNumber::BATTERY: + set_battery(rhs.get_battery()); + break; + + case FieldNumber::FLASHSTATE: + set_flashState(rhs.get_flashState()); + break; + + case FieldNumber::DMBPRESSURE: + set_dmbPressure(rhs.get_dmbPressure()); + break; + + case FieldNumber::PBBPRESSURE: + set_pbbPressure(rhs.get_pbbPressure()); + break; + + case FieldNumber::PBBTEMPERATURE: + set_pbbTemperature(rhs.get_pbbTemperature()); + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + set_combustionControlStatus(rhs.get_combustionControlStatus()); + break; + + case FieldNumber::RCUPRESSURE: + set_rcuPressure(rhs.get_rcuPressure()); + break; + + case FieldNumber::RCUTEMPERATURE: + set_rcuTemperature(rhs.get_rcuTemperature()); + break; + + case FieldNumber::NOSLOADCELL: + set_nosLoadCell(rhs.get_nosLoadCell()); + break; + + case FieldNumber::RELAYSTATUS: + set_relayStatus(rhs.get_relayStatus()); + break; + + case FieldNumber::PADBOXSTATUS: + set_padBoxStatus(rhs.get_padBoxStatus()); + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + set_launchRailLoadCell(rhs.get_launchRailLoadCell()); + break; + + case FieldNumber::SOBTEMPERATURE: + set_sobTemperature(rhs.get_sobTemperature()); + break; + + case FieldNumber::PRESSURELOG: + set_pressureLog(rhs.get_pressureLog()); + break; + + default: + break; + } + + return *this; + } + + static constexpr char const* SOURCE_NAME = "source"; + inline void clear_source() { source_.clear(); } + inline void set_source(const Node& value) { source_ = value; } + inline void set_source(const Node&& value) { source_ = value; } + inline const Node& get_source() const { return source_.get(); } + inline Node source() const { return source_.get(); } + + static constexpr char const* TARGET_NAME = "target"; + inline void clear_target() { target_.clear(); } + inline void set_target(const Node& value) { target_ = value; } + inline void set_target(const Node&& value) { target_ = value; } + inline const Node& get_target() const { return target_.get(); } + inline Node target() const { return target_.get(); } + + FieldNumber get_which_message() const { return which_message_; } + + static constexpr char const* GPS_NAME = "gps"; + inline bool has_gps() const + { + return FieldNumber::GPS == which_message_; + } + inline void clear_gps() + { + if(FieldNumber::GPS == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.gps_.~Gps(); + } + } + inline void set_gps(const Gps& value) + { + if(FieldNumber::GPS != which_message_) + { + init_message(FieldNumber::GPS); + } + message_.gps_ = value; + } + inline void set_gps(const Gps&& value) + { + if(FieldNumber::GPS != which_message_) + { + init_message(FieldNumber::GPS); + } + message_.gps_ = value; + } + inline Gps& mutable_gps() + { + if(FieldNumber::GPS != which_message_) + { + init_message(FieldNumber::GPS); + } + return message_.gps_; + } + inline const Gps& get_gps() const { return message_.gps_; } + inline const Gps& gps() const { return message_.gps_; } + + static constexpr char const* BARO_NAME = "baro"; + inline bool has_baro() const + { + return FieldNumber::BARO == which_message_; + } + inline void clear_baro() + { + if(FieldNumber::BARO == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.baro_.~Baro(); + } + } + inline void set_baro(const Baro& value) + { + if(FieldNumber::BARO != which_message_) + { + init_message(FieldNumber::BARO); + } + message_.baro_ = value; + } + inline void set_baro(const Baro&& value) + { + if(FieldNumber::BARO != which_message_) + { + init_message(FieldNumber::BARO); + } + message_.baro_ = value; + } + inline Baro& mutable_baro() + { + if(FieldNumber::BARO != which_message_) + { + init_message(FieldNumber::BARO); + } + return message_.baro_; + } + inline const Baro& get_baro() const { return message_.baro_; } + inline const Baro& baro() const { return message_.baro_; } + + static constexpr char const* IMU_NAME = "imu"; + inline bool has_imu() const + { + return FieldNumber::IMU == which_message_; + } + inline void clear_imu() + { + if(FieldNumber::IMU == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.imu_.~Imu(); + } + } + inline void set_imu(const Imu& value) + { + if(FieldNumber::IMU != which_message_) + { + init_message(FieldNumber::IMU); + } + message_.imu_ = value; + } + inline void set_imu(const Imu&& value) + { + if(FieldNumber::IMU != which_message_) + { + init_message(FieldNumber::IMU); + } + message_.imu_ = value; + } + inline Imu& mutable_imu() + { + if(FieldNumber::IMU != which_message_) + { + init_message(FieldNumber::IMU); + } + return message_.imu_; + } + inline const Imu& get_imu() const { return message_.imu_; } + inline const Imu& imu() const { return message_.imu_; } + + static constexpr char const* BATTERY_NAME = "battery"; + inline bool has_battery() const + { + return FieldNumber::BATTERY == which_message_; + } + inline void clear_battery() + { + if(FieldNumber::BATTERY == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.battery_.~Battery(); + } + } + inline void set_battery(const Battery& value) + { + if(FieldNumber::BATTERY != which_message_) + { + init_message(FieldNumber::BATTERY); + } + message_.battery_ = value; + } + inline void set_battery(const Battery&& value) + { + if(FieldNumber::BATTERY != which_message_) + { + init_message(FieldNumber::BATTERY); + } + message_.battery_ = value; + } + inline Battery& mutable_battery() + { + if(FieldNumber::BATTERY != which_message_) + { + init_message(FieldNumber::BATTERY); + } + return message_.battery_; + } + inline const Battery& get_battery() const { return message_.battery_; } + inline const Battery& battery() const { return message_.battery_; } + + static constexpr char const* FLASHSTATE_NAME = "flashState"; + inline bool has_flashState() const + { + return FieldNumber::FLASHSTATE == which_message_; + } + inline void clear_flashState() + { + if(FieldNumber::FLASHSTATE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.flashState_.~Flash(); + } + } + inline void set_flashState(const Flash& value) + { + if(FieldNumber::FLASHSTATE != which_message_) + { + init_message(FieldNumber::FLASHSTATE); + } + message_.flashState_ = value; + } + inline void set_flashState(const Flash&& value) + { + if(FieldNumber::FLASHSTATE != which_message_) + { + init_message(FieldNumber::FLASHSTATE); + } + message_.flashState_ = value; + } + inline Flash& mutable_flashState() + { + if(FieldNumber::FLASHSTATE != which_message_) + { + init_message(FieldNumber::FLASHSTATE); + } + return message_.flashState_; + } + inline const Flash& get_flashState() const { return message_.flashState_; } + inline const Flash& flashState() const { return message_.flashState_; } + + static constexpr char const* DMBPRESSURE_NAME = "dmbPressure"; + inline bool has_dmbPressure() const + { + return FieldNumber::DMBPRESSURE == which_message_; + } + inline void clear_dmbPressure() + { + if(FieldNumber::DMBPRESSURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.dmbPressure_.~DmbPressure(); + } + } + inline void set_dmbPressure(const DmbPressure& value) + { + if(FieldNumber::DMBPRESSURE != which_message_) + { + init_message(FieldNumber::DMBPRESSURE); + } + message_.dmbPressure_ = value; + } + inline void set_dmbPressure(const DmbPressure&& value) + { + if(FieldNumber::DMBPRESSURE != which_message_) + { + init_message(FieldNumber::DMBPRESSURE); + } + message_.dmbPressure_ = value; + } + inline DmbPressure& mutable_dmbPressure() + { + if(FieldNumber::DMBPRESSURE != which_message_) + { + init_message(FieldNumber::DMBPRESSURE); + } + return message_.dmbPressure_; + } + inline const DmbPressure& get_dmbPressure() const { return message_.dmbPressure_; } + inline const DmbPressure& dmbPressure() const { return message_.dmbPressure_; } + + static constexpr char const* PBBPRESSURE_NAME = "pbbPressure"; + inline bool has_pbbPressure() const + { + return FieldNumber::PBBPRESSURE == which_message_; + } + inline void clear_pbbPressure() + { + if(FieldNumber::PBBPRESSURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.pbbPressure_.~PbbPressure(); + } + } + inline void set_pbbPressure(const PbbPressure& value) + { + if(FieldNumber::PBBPRESSURE != which_message_) + { + init_message(FieldNumber::PBBPRESSURE); + } + message_.pbbPressure_ = value; + } + inline void set_pbbPressure(const PbbPressure&& value) + { + if(FieldNumber::PBBPRESSURE != which_message_) + { + init_message(FieldNumber::PBBPRESSURE); + } + message_.pbbPressure_ = value; + } + inline PbbPressure& mutable_pbbPressure() + { + if(FieldNumber::PBBPRESSURE != which_message_) + { + init_message(FieldNumber::PBBPRESSURE); + } + return message_.pbbPressure_; + } + inline const PbbPressure& get_pbbPressure() const { return message_.pbbPressure_; } + inline const PbbPressure& pbbPressure() const { return message_.pbbPressure_; } + + static constexpr char const* PBBTEMPERATURE_NAME = "pbbTemperature"; + inline bool has_pbbTemperature() const + { + return FieldNumber::PBBTEMPERATURE == which_message_; + } + inline void clear_pbbTemperature() + { + if(FieldNumber::PBBTEMPERATURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.pbbTemperature_.~PbbTemperature(); + } + } + inline void set_pbbTemperature(const PbbTemperature& value) + { + if(FieldNumber::PBBTEMPERATURE != which_message_) + { + init_message(FieldNumber::PBBTEMPERATURE); + } + message_.pbbTemperature_ = value; + } + inline void set_pbbTemperature(const PbbTemperature&& value) + { + if(FieldNumber::PBBTEMPERATURE != which_message_) + { + init_message(FieldNumber::PBBTEMPERATURE); + } + message_.pbbTemperature_ = value; + } + inline PbbTemperature& mutable_pbbTemperature() + { + if(FieldNumber::PBBTEMPERATURE != which_message_) + { + init_message(FieldNumber::PBBTEMPERATURE); + } + return message_.pbbTemperature_; + } + inline const PbbTemperature& get_pbbTemperature() const { return message_.pbbTemperature_; } + inline const PbbTemperature& pbbTemperature() const { return message_.pbbTemperature_; } + + static constexpr char const* COMBUSTIONCONTROLSTATUS_NAME = "combustionControlStatus"; + inline bool has_combustionControlStatus() const + { + return FieldNumber::COMBUSTIONCONTROLSTATUS == which_message_; + } + inline void clear_combustionControlStatus() + { + if(FieldNumber::COMBUSTIONCONTROLSTATUS == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.combustionControlStatus_.~CombustionControlStatus(); + } + } + inline void set_combustionControlStatus(const CombustionControlStatus& value) + { + if(FieldNumber::COMBUSTIONCONTROLSTATUS != which_message_) + { + init_message(FieldNumber::COMBUSTIONCONTROLSTATUS); + } + message_.combustionControlStatus_ = value; + } + inline void set_combustionControlStatus(const CombustionControlStatus&& value) + { + if(FieldNumber::COMBUSTIONCONTROLSTATUS != which_message_) + { + init_message(FieldNumber::COMBUSTIONCONTROLSTATUS); + } + message_.combustionControlStatus_ = value; + } + inline CombustionControlStatus& mutable_combustionControlStatus() + { + if(FieldNumber::COMBUSTIONCONTROLSTATUS != which_message_) + { + init_message(FieldNumber::COMBUSTIONCONTROLSTATUS); + } + return message_.combustionControlStatus_; + } + inline const CombustionControlStatus& get_combustionControlStatus() const { return message_.combustionControlStatus_; } + inline const CombustionControlStatus& combustionControlStatus() const { return message_.combustionControlStatus_; } + + static constexpr char const* RCUPRESSURE_NAME = "rcuPressure"; + inline bool has_rcuPressure() const + { + return FieldNumber::RCUPRESSURE == which_message_; + } + inline void clear_rcuPressure() + { + if(FieldNumber::RCUPRESSURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.rcuPressure_.~RcuPressure(); + } + } + inline void set_rcuPressure(const RcuPressure& value) + { + if(FieldNumber::RCUPRESSURE != which_message_) + { + init_message(FieldNumber::RCUPRESSURE); + } + message_.rcuPressure_ = value; + } + inline void set_rcuPressure(const RcuPressure&& value) + { + if(FieldNumber::RCUPRESSURE != which_message_) + { + init_message(FieldNumber::RCUPRESSURE); + } + message_.rcuPressure_ = value; + } + inline RcuPressure& mutable_rcuPressure() + { + if(FieldNumber::RCUPRESSURE != which_message_) + { + init_message(FieldNumber::RCUPRESSURE); + } + return message_.rcuPressure_; + } + inline const RcuPressure& get_rcuPressure() const { return message_.rcuPressure_; } + inline const RcuPressure& rcuPressure() const { return message_.rcuPressure_; } + + static constexpr char const* RCUTEMPERATURE_NAME = "rcuTemperature"; + inline bool has_rcuTemperature() const + { + return FieldNumber::RCUTEMPERATURE == which_message_; + } + inline void clear_rcuTemperature() + { + if(FieldNumber::RCUTEMPERATURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.rcuTemperature_.~RcuTemperature(); + } + } + inline void set_rcuTemperature(const RcuTemperature& value) + { + if(FieldNumber::RCUTEMPERATURE != which_message_) + { + init_message(FieldNumber::RCUTEMPERATURE); + } + message_.rcuTemperature_ = value; + } + inline void set_rcuTemperature(const RcuTemperature&& value) + { + if(FieldNumber::RCUTEMPERATURE != which_message_) + { + init_message(FieldNumber::RCUTEMPERATURE); + } + message_.rcuTemperature_ = value; + } + inline RcuTemperature& mutable_rcuTemperature() + { + if(FieldNumber::RCUTEMPERATURE != which_message_) + { + init_message(FieldNumber::RCUTEMPERATURE); + } + return message_.rcuTemperature_; + } + inline const RcuTemperature& get_rcuTemperature() const { return message_.rcuTemperature_; } + inline const RcuTemperature& rcuTemperature() const { return message_.rcuTemperature_; } + + static constexpr char const* NOSLOADCELL_NAME = "nosLoadCell"; + inline bool has_nosLoadCell() const + { + return FieldNumber::NOSLOADCELL == which_message_; + } + inline void clear_nosLoadCell() + { + if(FieldNumber::NOSLOADCELL == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.nosLoadCell_.~NosLoadCell(); + } + } + inline void set_nosLoadCell(const NosLoadCell& value) + { + if(FieldNumber::NOSLOADCELL != which_message_) + { + init_message(FieldNumber::NOSLOADCELL); + } + message_.nosLoadCell_ = value; + } + inline void set_nosLoadCell(const NosLoadCell&& value) + { + if(FieldNumber::NOSLOADCELL != which_message_) + { + init_message(FieldNumber::NOSLOADCELL); + } + message_.nosLoadCell_ = value; + } + inline NosLoadCell& mutable_nosLoadCell() + { + if(FieldNumber::NOSLOADCELL != which_message_) + { + init_message(FieldNumber::NOSLOADCELL); + } + return message_.nosLoadCell_; + } + inline const NosLoadCell& get_nosLoadCell() const { return message_.nosLoadCell_; } + inline const NosLoadCell& nosLoadCell() const { return message_.nosLoadCell_; } + + static constexpr char const* RELAYSTATUS_NAME = "relayStatus"; + inline bool has_relayStatus() const + { + return FieldNumber::RELAYSTATUS == which_message_; + } + inline void clear_relayStatus() + { + if(FieldNumber::RELAYSTATUS == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.relayStatus_.~RelayStatus(); + } + } + inline void set_relayStatus(const RelayStatus& value) + { + if(FieldNumber::RELAYSTATUS != which_message_) + { + init_message(FieldNumber::RELAYSTATUS); + } + message_.relayStatus_ = value; + } + inline void set_relayStatus(const RelayStatus&& value) + { + if(FieldNumber::RELAYSTATUS != which_message_) + { + init_message(FieldNumber::RELAYSTATUS); + } + message_.relayStatus_ = value; + } + inline RelayStatus& mutable_relayStatus() + { + if(FieldNumber::RELAYSTATUS != which_message_) + { + init_message(FieldNumber::RELAYSTATUS); + } + return message_.relayStatus_; + } + inline const RelayStatus& get_relayStatus() const { return message_.relayStatus_; } + inline const RelayStatus& relayStatus() const { return message_.relayStatus_; } + + static constexpr char const* PADBOXSTATUS_NAME = "padBoxStatus"; + inline bool has_padBoxStatus() const + { + return FieldNumber::PADBOXSTATUS == which_message_; + } + inline void clear_padBoxStatus() + { + if(FieldNumber::PADBOXSTATUS == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.padBoxStatus_.~PadBoxStatus(); + } + } + inline void set_padBoxStatus(const PadBoxStatus& value) + { + if(FieldNumber::PADBOXSTATUS != which_message_) + { + init_message(FieldNumber::PADBOXSTATUS); + } + message_.padBoxStatus_ = value; + } + inline void set_padBoxStatus(const PadBoxStatus&& value) + { + if(FieldNumber::PADBOXSTATUS != which_message_) + { + init_message(FieldNumber::PADBOXSTATUS); + } + message_.padBoxStatus_ = value; + } + inline PadBoxStatus& mutable_padBoxStatus() + { + if(FieldNumber::PADBOXSTATUS != which_message_) + { + init_message(FieldNumber::PADBOXSTATUS); + } + return message_.padBoxStatus_; + } + inline const PadBoxStatus& get_padBoxStatus() const { return message_.padBoxStatus_; } + inline const PadBoxStatus& padBoxStatus() const { return message_.padBoxStatus_; } + + static constexpr char const* LAUNCHRAILLOADCELL_NAME = "launchRailLoadCell"; + inline bool has_launchRailLoadCell() const + { + return FieldNumber::LAUNCHRAILLOADCELL == which_message_; + } + inline void clear_launchRailLoadCell() + { + if(FieldNumber::LAUNCHRAILLOADCELL == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.launchRailLoadCell_.~LaunchRailLoadCell(); + } + } + inline void set_launchRailLoadCell(const LaunchRailLoadCell& value) + { + if(FieldNumber::LAUNCHRAILLOADCELL != which_message_) + { + init_message(FieldNumber::LAUNCHRAILLOADCELL); + } + message_.launchRailLoadCell_ = value; + } + inline void set_launchRailLoadCell(const LaunchRailLoadCell&& value) + { + if(FieldNumber::LAUNCHRAILLOADCELL != which_message_) + { + init_message(FieldNumber::LAUNCHRAILLOADCELL); + } + message_.launchRailLoadCell_ = value; + } + inline LaunchRailLoadCell& mutable_launchRailLoadCell() + { + if(FieldNumber::LAUNCHRAILLOADCELL != which_message_) + { + init_message(FieldNumber::LAUNCHRAILLOADCELL); + } + return message_.launchRailLoadCell_; + } + inline const LaunchRailLoadCell& get_launchRailLoadCell() const { return message_.launchRailLoadCell_; } + inline const LaunchRailLoadCell& launchRailLoadCell() const { return message_.launchRailLoadCell_; } + + static constexpr char const* SOBTEMPERATURE_NAME = "sobTemperature"; + inline bool has_sobTemperature() const + { + return FieldNumber::SOBTEMPERATURE == which_message_; + } + inline void clear_sobTemperature() + { + if(FieldNumber::SOBTEMPERATURE == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.sobTemperature_.~SobTemperature(); + } + } + inline void set_sobTemperature(const SobTemperature& value) + { + if(FieldNumber::SOBTEMPERATURE != which_message_) + { + init_message(FieldNumber::SOBTEMPERATURE); + } + message_.sobTemperature_ = value; + } + inline void set_sobTemperature(const SobTemperature&& value) + { + if(FieldNumber::SOBTEMPERATURE != which_message_) + { + init_message(FieldNumber::SOBTEMPERATURE); + } + message_.sobTemperature_ = value; + } + inline SobTemperature& mutable_sobTemperature() + { + if(FieldNumber::SOBTEMPERATURE != which_message_) + { + init_message(FieldNumber::SOBTEMPERATURE); + } + return message_.sobTemperature_; + } + inline const SobTemperature& get_sobTemperature() const { return message_.sobTemperature_; } + inline const SobTemperature& sobTemperature() const { return message_.sobTemperature_; } + + static constexpr char const* PRESSURELOG_NAME = "pressureLog"; + inline bool has_pressureLog() const + { + return FieldNumber::PRESSURELOG == which_message_; + } + inline void clear_pressureLog() + { + if(FieldNumber::PRESSURELOG == which_message_) + { + which_message_ = FieldNumber::NOT_SET; + message_.pressureLog_.~PressureLog(); + } + } + inline void set_pressureLog(const PressureLog& value) + { + if(FieldNumber::PRESSURELOG != which_message_) + { + init_message(FieldNumber::PRESSURELOG); + } + message_.pressureLog_ = value; + } + inline void set_pressureLog(const PressureLog&& value) + { + if(FieldNumber::PRESSURELOG != which_message_) + { + init_message(FieldNumber::PRESSURELOG); + } + message_.pressureLog_ = value; + } + inline PressureLog& mutable_pressureLog() + { + if(FieldNumber::PRESSURELOG != which_message_) + { + init_message(FieldNumber::PRESSURELOG); + } + return message_.pressureLog_; + } + inline const PressureLog& get_pressureLog() const { return message_.pressureLog_; } + inline const PressureLog& pressureLog() const { return message_.pressureLog_; } + + + ::EmbeddedProto::Error serialize(::EmbeddedProto::WriteBufferInterface& buffer) const override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if((static_cast(0) != source_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = source_.serialize_with_id(static_cast(FieldNumber::SOURCE), buffer, false); + } + + if((static_cast(0) != target_.get()) && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = target_.serialize_with_id(static_cast(FieldNumber::TARGET), buffer, false); + } + + switch(which_message_) + { + case FieldNumber::GPS: + if(has_gps() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.gps_.serialize_with_id(static_cast(FieldNumber::GPS), buffer, true); + } + break; + + case FieldNumber::BARO: + if(has_baro() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.baro_.serialize_with_id(static_cast(FieldNumber::BARO), buffer, true); + } + break; + + case FieldNumber::IMU: + if(has_imu() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.imu_.serialize_with_id(static_cast(FieldNumber::IMU), buffer, true); + } + break; + + case FieldNumber::BATTERY: + if(has_battery() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.battery_.serialize_with_id(static_cast(FieldNumber::BATTERY), buffer, true); + } + break; + + case FieldNumber::FLASHSTATE: + if(has_flashState() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.flashState_.serialize_with_id(static_cast(FieldNumber::FLASHSTATE), buffer, true); + } + break; + + case FieldNumber::DMBPRESSURE: + if(has_dmbPressure() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.dmbPressure_.serialize_with_id(static_cast(FieldNumber::DMBPRESSURE), buffer, true); + } + break; + + case FieldNumber::PBBPRESSURE: + if(has_pbbPressure() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.pbbPressure_.serialize_with_id(static_cast(FieldNumber::PBBPRESSURE), buffer, true); + } + break; + + case FieldNumber::PBBTEMPERATURE: + if(has_pbbTemperature() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.pbbTemperature_.serialize_with_id(static_cast(FieldNumber::PBBTEMPERATURE), buffer, true); + } + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + if(has_combustionControlStatus() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.combustionControlStatus_.serialize_with_id(static_cast(FieldNumber::COMBUSTIONCONTROLSTATUS), buffer, true); + } + break; + + case FieldNumber::RCUPRESSURE: + if(has_rcuPressure() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.rcuPressure_.serialize_with_id(static_cast(FieldNumber::RCUPRESSURE), buffer, true); + } + break; + + case FieldNumber::RCUTEMPERATURE: + if(has_rcuTemperature() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.rcuTemperature_.serialize_with_id(static_cast(FieldNumber::RCUTEMPERATURE), buffer, true); + } + break; + + case FieldNumber::NOSLOADCELL: + if(has_nosLoadCell() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.nosLoadCell_.serialize_with_id(static_cast(FieldNumber::NOSLOADCELL), buffer, true); + } + break; + + case FieldNumber::RELAYSTATUS: + if(has_relayStatus() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.relayStatus_.serialize_with_id(static_cast(FieldNumber::RELAYSTATUS), buffer, true); + } + break; + + case FieldNumber::PADBOXSTATUS: + if(has_padBoxStatus() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.padBoxStatus_.serialize_with_id(static_cast(FieldNumber::PADBOXSTATUS), buffer, true); + } + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + if(has_launchRailLoadCell() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.launchRailLoadCell_.serialize_with_id(static_cast(FieldNumber::LAUNCHRAILLOADCELL), buffer, true); + } + break; + + case FieldNumber::SOBTEMPERATURE: + if(has_sobTemperature() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.sobTemperature_.serialize_with_id(static_cast(FieldNumber::SOBTEMPERATURE), buffer, true); + } + break; + + case FieldNumber::PRESSURELOG: + if(has_pressureLog() && (::EmbeddedProto::Error::NO_ERRORS == return_value)) + { + return_value = message_.pressureLog_.serialize_with_id(static_cast(FieldNumber::PRESSURELOG), buffer, true); + } + break; + + default: + break; + } + + return return_value; + }; + + ::EmbeddedProto::Error deserialize(::EmbeddedProto::ReadBufferInterface& buffer) override + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + ::EmbeddedProto::WireFormatter::WireType wire_type = ::EmbeddedProto::WireFormatter::WireType::VARINT; + uint32_t id_number = 0; + FieldNumber id_tag = FieldNumber::NOT_SET; + + ::EmbeddedProto::Error tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + while((::EmbeddedProto::Error::NO_ERRORS == return_value) && (::EmbeddedProto::Error::NO_ERRORS == tag_value)) + { + id_tag = static_cast(id_number); + switch(id_tag) + { + case FieldNumber::SOURCE: + return_value = source_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::TARGET: + return_value = target_.deserialize_check_type(buffer, wire_type); + break; + + case FieldNumber::GPS: + case FieldNumber::BARO: + case FieldNumber::IMU: + case FieldNumber::BATTERY: + case FieldNumber::FLASHSTATE: + case FieldNumber::DMBPRESSURE: + case FieldNumber::PBBPRESSURE: + case FieldNumber::PBBTEMPERATURE: + case FieldNumber::COMBUSTIONCONTROLSTATUS: + case FieldNumber::RCUPRESSURE: + case FieldNumber::RCUTEMPERATURE: + case FieldNumber::NOSLOADCELL: + case FieldNumber::RELAYSTATUS: + case FieldNumber::PADBOXSTATUS: + case FieldNumber::LAUNCHRAILLOADCELL: + case FieldNumber::SOBTEMPERATURE: + case FieldNumber::PRESSURELOG: + return_value = deserialize_message(id_tag, buffer, wire_type); + break; + + case FieldNumber::NOT_SET: + return_value = ::EmbeddedProto::Error::INVALID_FIELD_ID; + break; + + default: + return_value = skip_unknown_field(buffer, wire_type); + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS == return_value) + { + // Read the next tag. + tag_value = ::EmbeddedProto::WireFormatter::DeserializeTag(buffer, wire_type, id_number); + } + } + + // When an error was detect while reading the tag but no other errors where found, set it in the return value. + if((::EmbeddedProto::Error::NO_ERRORS == return_value) + && (::EmbeddedProto::Error::NO_ERRORS != tag_value) + && (::EmbeddedProto::Error::END_OF_BUFFER != tag_value)) // The end of the buffer is not an array in this case. + { + return_value = tag_value; + } + + return return_value; + }; + + void clear() override + { + clear_source(); + clear_target(); + clear_message(); + + } + +#ifndef DISABLE_FIELD_NUMBER_TO_NAME + + static char const* field_number_to_name(const FieldNumber fieldNumber) + { + char const* name = nullptr; + switch(fieldNumber) + { + case FieldNumber::SOURCE: + name = SOURCE_NAME; + break; + case FieldNumber::TARGET: + name = TARGET_NAME; + break; + case FieldNumber::GPS: + name = GPS_NAME; + break; + case FieldNumber::BARO: + name = BARO_NAME; + break; + case FieldNumber::IMU: + name = IMU_NAME; + break; + case FieldNumber::BATTERY: + name = BATTERY_NAME; + break; + case FieldNumber::FLASHSTATE: + name = FLASHSTATE_NAME; + break; + case FieldNumber::DMBPRESSURE: + name = DMBPRESSURE_NAME; + break; + case FieldNumber::PBBPRESSURE: + name = PBBPRESSURE_NAME; + break; + case FieldNumber::PBBTEMPERATURE: + name = PBBTEMPERATURE_NAME; + break; + case FieldNumber::COMBUSTIONCONTROLSTATUS: + name = COMBUSTIONCONTROLSTATUS_NAME; + break; + case FieldNumber::RCUPRESSURE: + name = RCUPRESSURE_NAME; + break; + case FieldNumber::RCUTEMPERATURE: + name = RCUTEMPERATURE_NAME; + break; + case FieldNumber::NOSLOADCELL: + name = NOSLOADCELL_NAME; + break; + case FieldNumber::RELAYSTATUS: + name = RELAYSTATUS_NAME; + break; + case FieldNumber::PADBOXSTATUS: + name = PADBOXSTATUS_NAME; + break; + case FieldNumber::LAUNCHRAILLOADCELL: + name = LAUNCHRAILLOADCELL_NAME; + break; + case FieldNumber::SOBTEMPERATURE: + name = SOBTEMPERATURE_NAME; + break; + case FieldNumber::PRESSURELOG: + name = PRESSURELOG_NAME; + break; + default: + name = "Invalid FieldNumber"; + break; + } + return name; + } + +#endif + +#ifdef MSG_TO_STRING + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str) const + { + return this->to_string(str, 0, nullptr, true); + } + + ::EmbeddedProto::string_view to_string(::EmbeddedProto::string_view& str, const uint32_t indent_level, char const* name, const bool first_field) const override + { + ::EmbeddedProto::string_view left_chars = str; + int32_t n_chars_used = 0; + + if(!first_field) + { + // Add a comma behind the previous field. + n_chars_used = snprintf(left_chars.data, left_chars.size, ",\n"); + if(0 < n_chars_used) + { + // Update the character pointer and characters left in the array. + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + } + + if(nullptr != name) + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\"%s\": {\n", name); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s\"%s\": {\n", indent_level, " ", name); + } + } + else + { + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "{\n"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "%*s{\n", indent_level, " "); + } + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + left_chars = source_.to_string(left_chars, indent_level + 2, SOURCE_NAME, true); + left_chars = target_.to_string(left_chars, indent_level + 2, TARGET_NAME, false); + left_chars = to_string_message(left_chars, indent_level + 2, false); + + if( 0 == indent_level) + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n}"); + } + else + { + n_chars_used = snprintf(left_chars.data, left_chars.size, "\n%*s}", indent_level, " "); + } + + if(0 < n_chars_used) + { + left_chars.data += n_chars_used; + left_chars.size -= n_chars_used; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING + + private: + + + EmbeddedProto::enumeration source_ = static_cast(0); + EmbeddedProto::enumeration target_ = static_cast(0); + + FieldNumber which_message_ = FieldNumber::NOT_SET; + union message + { + message() {} + ~message() {} + Gps gps_; + Baro baro_; + Imu imu_; + Battery battery_; + Flash flashState_; + DmbPressure dmbPressure_; + PbbPressure pbbPressure_; + PbbTemperature pbbTemperature_; + CombustionControlStatus combustionControlStatus_; + RcuPressure rcuPressure_; + RcuTemperature rcuTemperature_; + NosLoadCell nosLoadCell_; + RelayStatus relayStatus_; + PadBoxStatus padBoxStatus_; + LaunchRailLoadCell launchRailLoadCell_; + SobTemperature sobTemperature_; + PressureLog pressureLog_; + }; + message message_; + + void init_message(const FieldNumber field_id) + { + if(FieldNumber::NOT_SET != which_message_) + { + // First delete the old object in the oneof. + clear_message(); + } + + // C++11 unions only support nontrivial members when you explicitly call the placement new statement. + switch(field_id) + { + case FieldNumber::GPS: + new(&message_.gps_) Gps; + break; + + case FieldNumber::BARO: + new(&message_.baro_) Baro; + break; + + case FieldNumber::IMU: + new(&message_.imu_) Imu; + break; + + case FieldNumber::BATTERY: + new(&message_.battery_) Battery; + break; + + case FieldNumber::FLASHSTATE: + new(&message_.flashState_) Flash; + break; + + case FieldNumber::DMBPRESSURE: + new(&message_.dmbPressure_) DmbPressure; + break; + + case FieldNumber::PBBPRESSURE: + new(&message_.pbbPressure_) PbbPressure; + break; + + case FieldNumber::PBBTEMPERATURE: + new(&message_.pbbTemperature_) PbbTemperature; + break; + + case FieldNumber::COMBUSTIONCONTROLSTATUS: + new(&message_.combustionControlStatus_) CombustionControlStatus; + break; + + case FieldNumber::RCUPRESSURE: + new(&message_.rcuPressure_) RcuPressure; + break; + + case FieldNumber::RCUTEMPERATURE: + new(&message_.rcuTemperature_) RcuTemperature; + break; + + case FieldNumber::NOSLOADCELL: + new(&message_.nosLoadCell_) NosLoadCell; + break; + + case FieldNumber::RELAYSTATUS: + new(&message_.relayStatus_) RelayStatus; + break; + + case FieldNumber::PADBOXSTATUS: + new(&message_.padBoxStatus_) PadBoxStatus; + break; + + case FieldNumber::LAUNCHRAILLOADCELL: + new(&message_.launchRailLoadCell_) LaunchRailLoadCell; + break; + + case FieldNumber::SOBTEMPERATURE: + new(&message_.sobTemperature_) SobTemperature; + break; + + case FieldNumber::PRESSURELOG: + new(&message_.pressureLog_) PressureLog; + break; + + default: + break; + } + + which_message_ = field_id; + } + + void clear_message() + { + switch(which_message_) + { + case FieldNumber::GPS: + ::EmbeddedProto::destroy_at(&message_.gps_); + break; + case FieldNumber::BARO: + ::EmbeddedProto::destroy_at(&message_.baro_); + break; + case FieldNumber::IMU: + ::EmbeddedProto::destroy_at(&message_.imu_); + break; + case FieldNumber::BATTERY: + ::EmbeddedProto::destroy_at(&message_.battery_); + break; + case FieldNumber::FLASHSTATE: + ::EmbeddedProto::destroy_at(&message_.flashState_); + break; + case FieldNumber::DMBPRESSURE: + ::EmbeddedProto::destroy_at(&message_.dmbPressure_); + break; + case FieldNumber::PBBPRESSURE: + ::EmbeddedProto::destroy_at(&message_.pbbPressure_); + break; + case FieldNumber::PBBTEMPERATURE: + ::EmbeddedProto::destroy_at(&message_.pbbTemperature_); + break; + case FieldNumber::COMBUSTIONCONTROLSTATUS: + ::EmbeddedProto::destroy_at(&message_.combustionControlStatus_); + break; + case FieldNumber::RCUPRESSURE: + ::EmbeddedProto::destroy_at(&message_.rcuPressure_); + break; + case FieldNumber::RCUTEMPERATURE: + ::EmbeddedProto::destroy_at(&message_.rcuTemperature_); + break; + case FieldNumber::NOSLOADCELL: + ::EmbeddedProto::destroy_at(&message_.nosLoadCell_); + break; + case FieldNumber::RELAYSTATUS: + ::EmbeddedProto::destroy_at(&message_.relayStatus_); + break; + case FieldNumber::PADBOXSTATUS: + ::EmbeddedProto::destroy_at(&message_.padBoxStatus_); + break; + case FieldNumber::LAUNCHRAILLOADCELL: + ::EmbeddedProto::destroy_at(&message_.launchRailLoadCell_); + break; + case FieldNumber::SOBTEMPERATURE: + ::EmbeddedProto::destroy_at(&message_.sobTemperature_); + break; + case FieldNumber::PRESSURELOG: + ::EmbeddedProto::destroy_at(&message_.pressureLog_); + break; + default: + break; + } + which_message_ = FieldNumber::NOT_SET; + } + + ::EmbeddedProto::Error deserialize_message(const FieldNumber field_id, + ::EmbeddedProto::ReadBufferInterface& buffer, + const ::EmbeddedProto::WireFormatter::WireType wire_type) + { + ::EmbeddedProto::Error return_value = ::EmbeddedProto::Error::NO_ERRORS; + + if(field_id != which_message_) + { + init_message(field_id); + } + + switch(which_message_) + { + case FieldNumber::GPS: + return_value = message_.gps_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::BARO: + return_value = message_.baro_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::IMU: + return_value = message_.imu_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::BATTERY: + return_value = message_.battery_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::FLASHSTATE: + return_value = message_.flashState_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::DMBPRESSURE: + return_value = message_.dmbPressure_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PBBPRESSURE: + return_value = message_.pbbPressure_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PBBTEMPERATURE: + return_value = message_.pbbTemperature_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::COMBUSTIONCONTROLSTATUS: + return_value = message_.combustionControlStatus_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::RCUPRESSURE: + return_value = message_.rcuPressure_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::RCUTEMPERATURE: + return_value = message_.rcuTemperature_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::NOSLOADCELL: + return_value = message_.nosLoadCell_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::RELAYSTATUS: + return_value = message_.relayStatus_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PADBOXSTATUS: + return_value = message_.padBoxStatus_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::LAUNCHRAILLOADCELL: + return_value = message_.launchRailLoadCell_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::SOBTEMPERATURE: + return_value = message_.sobTemperature_.deserialize_check_type(buffer, wire_type); + break; + case FieldNumber::PRESSURELOG: + return_value = message_.pressureLog_.deserialize_check_type(buffer, wire_type); + break; + default: + break; + } + + if(::EmbeddedProto::Error::NO_ERRORS != return_value) + { + clear_message(); + } + return return_value; + } + +#ifdef MSG_TO_STRING + ::EmbeddedProto::string_view to_string_message(::EmbeddedProto::string_view& str, const uint32_t indent_level, const bool first_field) const + { + ::EmbeddedProto::string_view left_chars = str; + + switch(which_message_) + { + case FieldNumber::GPS: + left_chars = message_.gps_.to_string(left_chars, indent_level, GPS_NAME, first_field); + break; + case FieldNumber::BARO: + left_chars = message_.baro_.to_string(left_chars, indent_level, BARO_NAME, first_field); + break; + case FieldNumber::IMU: + left_chars = message_.imu_.to_string(left_chars, indent_level, IMU_NAME, first_field); + break; + case FieldNumber::BATTERY: + left_chars = message_.battery_.to_string(left_chars, indent_level, BATTERY_NAME, first_field); + break; + case FieldNumber::FLASHSTATE: + left_chars = message_.flashState_.to_string(left_chars, indent_level, FLASHSTATE_NAME, first_field); + break; + case FieldNumber::DMBPRESSURE: + left_chars = message_.dmbPressure_.to_string(left_chars, indent_level, DMBPRESSURE_NAME, first_field); + break; + case FieldNumber::PBBPRESSURE: + left_chars = message_.pbbPressure_.to_string(left_chars, indent_level, PBBPRESSURE_NAME, first_field); + break; + case FieldNumber::PBBTEMPERATURE: + left_chars = message_.pbbTemperature_.to_string(left_chars, indent_level, PBBTEMPERATURE_NAME, first_field); + break; + case FieldNumber::COMBUSTIONCONTROLSTATUS: + left_chars = message_.combustionControlStatus_.to_string(left_chars, indent_level, COMBUSTIONCONTROLSTATUS_NAME, first_field); + break; + case FieldNumber::RCUPRESSURE: + left_chars = message_.rcuPressure_.to_string(left_chars, indent_level, RCUPRESSURE_NAME, first_field); + break; + case FieldNumber::RCUTEMPERATURE: + left_chars = message_.rcuTemperature_.to_string(left_chars, indent_level, RCUTEMPERATURE_NAME, first_field); + break; + case FieldNumber::NOSLOADCELL: + left_chars = message_.nosLoadCell_.to_string(left_chars, indent_level, NOSLOADCELL_NAME, first_field); + break; + case FieldNumber::RELAYSTATUS: + left_chars = message_.relayStatus_.to_string(left_chars, indent_level, RELAYSTATUS_NAME, first_field); + break; + case FieldNumber::PADBOXSTATUS: + left_chars = message_.padBoxStatus_.to_string(left_chars, indent_level, PADBOXSTATUS_NAME, first_field); + break; + case FieldNumber::LAUNCHRAILLOADCELL: + left_chars = message_.launchRailLoadCell_.to_string(left_chars, indent_level, LAUNCHRAILLOADCELL_NAME, first_field); + break; + case FieldNumber::SOBTEMPERATURE: + left_chars = message_.sobTemperature_.to_string(left_chars, indent_level, SOBTEMPERATURE_NAME, first_field); + break; + case FieldNumber::PRESSURELOG: + left_chars = message_.pressureLog_.to_string(left_chars, indent_level, PRESSURELOG_NAME, first_field); + break; + default: + break; + } + + return left_chars; + } + +#endif // End of MSG_TO_STRING +}; + +} // End of namespace Proto +#endif // TELEMETRYMESSAGE_H \ No newline at end of file diff --git a/SoarProto/_Python/CommandMessage_pb2.py b/SoarProto/_Python/CommandMessage_pb2.py new file mode 100644 index 0000000..f1dcc5a --- /dev/null +++ b/SoarProto/_Python/CommandMessage_pb2.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: CommandMessage.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +import CoreProto_pb2 as CoreProto__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x14\x43ommandMessage.proto\x12\x05Proto\x1a\x0f\x43oreProto.proto\"\x9a\x02\n\x0e\x43ommandMessage\x12\x1b\n\x06source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x06target\x18\x02 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x13source_sequence_num\x18\x03 \x01(\r\x12(\n\x0b\x66cb_command\x18\x04 \x01(\x0b\x32\x11.Proto.FcbCommandH\x00\x12(\n\x0bpbb_command\x18\x05 \x01(\x0b\x32\x11.Proto.PbbCommandH\x00\x12(\n\x0bfsb_command\x18\x06 \x01(\x0b\x32\x11.Proto.FsbCommandH\x00\x12(\n\x0blrb_command\x18\x07 \x01(\x0b\x32\x11.Proto.LrbCommandH\x00\x42\t\n\x07message\"\x8d\x05\n\nFcbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FcbCommand.Command\"\xcd\x04\n\x07\x43ommand\x12\x15\n\x11RSC_FIRST_INVALID\x10\x00\x12\x14\n\x10RSC_ANY_TO_ABORT\x10\x01\x12\x11\n\rRSC_OPEN_VENT\x10\x02\x12\x12\n\x0eRSC_CLOSE_VENT\x10\x03\x12\x12\n\x0eRSC_OPEN_DRAIN\x10\x04\x12\x13\n\x0fRSC_CLOSE_DRAIN\x10\x05\x12\x11\n\rRSC_MEV_CLOSE\x10\x06\x12\x11\n\rRSC_GOTO_FILL\x10\x07\x12\x15\n\x11RSC_ARM_CONFIRM_1\x10\x08\x12\x15\n\x11RSC_ARM_CONFIRM_2\x10\t\x12\x10\n\x0cRSC_GOTO_ARM\x10\n\x12\x16\n\x12RSC_GOTO_PRELAUNCH\x10\x0b\x12 \n\x1cRSC_POWER_TRANSITION_ONBOARD\x10\x0c\x12!\n\x1dRSC_POWER_TRANSITION_EXTERNAL\x10\r\x12\x15\n\x11RSC_GOTO_IGNITION\x10\x0e\x12\x1a\n\x16RSC_IGNITION_TO_LAUNCH\x10\x0f\x12\x16\n\x12RSC_LAUNCH_TO_BURN\x10\x10\x12\x15\n\x11RSC_BURN_TO_COAST\x10\x11\x12\x18\n\x14RSC_COAST_TO_DESCENT\x10\x12\x12\x1b\n\x17RSC_DESCENT_TO_RECOVERY\x10\x13\x12\x11\n\rRSC_GOTO_TEST\x10\x14\x12\x15\n\x11RSC_TEST_MEV_OPEN\x10\x15\x12\x17\n\x13RSC_TEST_MEV_ENABLE\x10\x16\x12\x18\n\x14RSC_TEST_MEV_DISABLE\x10\x17\x12\x0c\n\x08RSC_NONE\x10\x18\"\x89\x01\n\nPbbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.PbbCommand.Command\"J\n\x07\x43ommand\x12\x0c\n\x08PBB_NONE\x10\x00\x12\x10\n\x0cPBB_OPEN_MEV\x10\x01\x12\x11\n\rPBB_CLOSE_MEV\x10\x02\x12\x0c\n\x08PMB_LAST\x10\x05\"\xe1\x01\n\nLrbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.LrbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"\x8a\x01\n\x07\x43ommand\x12\x0c\n\x08SOB_NONE\x10\x00\x12\x16\n\x12SOB_SLOW_SAMPLE_IR\x10\x01\x12\x16\n\x12SOB_FAST_SAMPLE_IR\x10\x02\x12\x16\n\x12SOB_TARE_LOAD_CELL\x10\x03\x12\x1b\n\x17SOB_CALIBRATE_LOAD_CELL\x10\x04\x12\x0c\n\x08SOB_LAST\x10\x05\"\x87\x06\n\nFsbCommand\x12/\n\x0c\x63ommand_enum\x18\x01 \x01(\x0e\x32\x19.Proto.FsbCommand.Command\x12\x15\n\rcommand_param\x18\x02 \x01(\x05\"\xb0\x05\n\x07\x43ommand\x12\x0c\n\x08RCU_NONE\x10\x00\x12\x10\n\x0cRCU_OPEN_AC1\x10\x03\x12\x11\n\rRCU_CLOSE_AC1\x10\x04\x12\x10\n\x0cRCU_OPEN_AC2\x10\x05\x12\x11\n\rRCU_CLOSE_AC2\x10\x06\x12\x11\n\rRCU_OPEN_PBV1\x10\x07\x12\x12\n\x0eRCU_CLOSE_PBV1\x10\x08\x12\x11\n\rRCU_OPEN_PBV2\x10\t\x12\x12\n\x0eRCU_CLOSE_PBV2\x10\n\x12\x11\n\rRCU_OPEN_PBV3\x10\x0b\x12\x12\n\x0eRCU_CLOSE_PBV3\x10\x0c\x12\x11\n\rRCU_OPEN_PBV4\x10\r\x12\x12\n\x0eRCU_CLOSE_PBV4\x10\x0e\x12\x11\n\rRCU_OPEN_SOL5\x10\x15\x12\x12\n\x0eRCU_CLOSE_SOL5\x10\x16\x12\x11\n\rRCU_OPEN_SOL6\x10\x17\x12\x12\n\x0eRCU_CLOSE_SOL6\x10\x18\x12\x11\n\rRCU_OPEN_SOL7\x10\x19\x12\x12\n\x0eRCU_CLOSE_SOL7\x10\x1a\x12\x12\n\x0eRCU_OPEN_SOL8A\x10\x1b\x12\x13\n\x0fRCU_CLOSE_SOL8A\x10\x1c\x12\x12\n\x0eRCU_OPEN_SOL8B\x10\x1d\x12\x13\n\x0fRCU_CLOSE_SOL8B\x10\x1e\x12\x1b\n\x17RCU_TARE_NOS1_LOAD_CELL\x10!\x12\x1b\n\x17RCU_TARE_NOS2_LOAD_CELL\x10\"\x12 \n\x1cRCU_CALIBRATE_NOS1_LOAD_CELL\x10#\x12 \n\x1cRCU_CALIBRATE_NOS2_LOAD_CELL\x10$\x12\x17\n\x13RCU_IGNITE_PAD_BOX1\x10\x1f\x12\x17\n\x13RCU_IGNITE_PAD_BOX2\x10 \x12\x15\n\x11RCU_KILL_PAD_BOX1\x10%\x12\x15\n\x11RCU_KILL_PAD_BOX2\x10&\x12\x0c\n\x08RCU_LAST\x10\'b\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'CommandMessage_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_COMMANDMESSAGE']._serialized_start=49 + _globals['_COMMANDMESSAGE']._serialized_end=331 + _globals['_DMBCOMMAND']._serialized_start=334 + _globals['_DMBCOMMAND']._serialized_end=987 + _globals['_DMBCOMMAND_COMMAND']._serialized_start=398 + _globals['_DMBCOMMAND_COMMAND']._serialized_end=987 + _globals['_PBBCOMMAND']._serialized_start=990 + _globals['_PBBCOMMAND']._serialized_end=1127 + _globals['_PBBCOMMAND_COMMAND']._serialized_start=1053 + _globals['_PBBCOMMAND_COMMAND']._serialized_end=1127 + _globals['_SOBCOMMAND']._serialized_start=1130 + _globals['_SOBCOMMAND']._serialized_end=1355 + _globals['_SOBCOMMAND_COMMAND']._serialized_start=1217 + _globals['_SOBCOMMAND_COMMAND']._serialized_end=1355 + _globals['_RCUCOMMAND']._serialized_start=1358 + _globals['_RCUCOMMAND']._serialized_end=2133 + _globals['_RCUCOMMAND_COMMAND']._serialized_start=1445 + _globals['_RCUCOMMAND_COMMAND']._serialized_end=2133 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/CommandMessage_pb2.pyi b/SoarProto/_Python/CommandMessage_pb2.pyi new file mode 100644 index 0000000..a0755d5 --- /dev/null +++ b/SoarProto/_Python/CommandMessage_pb2.pyi @@ -0,0 +1,292 @@ +import CoreProto_pb2 as _CoreProto_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CommandMessage(_message.Message): + __slots__ = ("source", "target", "source_sequence_num", "dmb_command", "pbb_command", "rcu_command", "sob_command") + SOURCE_FIELD_NUMBER: _ClassVar[int] + TARGET_FIELD_NUMBER: _ClassVar[int] + SOURCE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + DMB_COMMAND_FIELD_NUMBER: _ClassVar[int] + __slots__ = ["fcb_command", "pbb_command", "fsb_command", "lrb_command", "source", "source_sequence_num", "target"] + FCB_COMMAND_FIELD_NUMBER: _ClassVar[int] + PBB_COMMAND_FIELD_NUMBER: _ClassVar[int] + RCU_COMMAND_FIELD_NUMBER: _ClassVar[int] + SOB_COMMAND_FIELD_NUMBER: _ClassVar[int] + source: _CoreProto_pb2.Node + target: _CoreProto_pb2.Node + source_sequence_num: int + dmb_command: DmbCommand + FSB_COMMAND_FIELD_NUMBER: _ClassVar[int] + LRB_COMMAND_FIELD_NUMBER: _ClassVar[int] + SOURCE_FIELD_NUMBER: _ClassVar[int] + SOURCE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + TARGET_FIELD_NUMBER: _ClassVar[int] + fcb_command: FcbCommand + pbb_command: PbbCommand + rcu_command: RcuCommand + sob_command: SobCommand + def __init__(self, source: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., target: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., source_sequence_num: _Optional[int] = ..., dmb_command: _Optional[_Union[DmbCommand, _Mapping]] = ..., pbb_command: _Optional[_Union[PbbCommand, _Mapping]] = ..., rcu_command: _Optional[_Union[RcuCommand, _Mapping]] = ..., sob_command: _Optional[_Union[SobCommand, _Mapping]] = ...) -> None: ... + fsb_command: FsbCommand + lrb_command: LrbCommand + source: _CoreProto_pb2.Node + source_sequence_num: int + target: _CoreProto_pb2.Node + def __init__(self, source: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., target: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., source_sequence_num: _Optional[int] = ..., fcb_command: _Optional[_Union[FcbCommand, _Mapping]] = ..., pbb_command: _Optional[_Union[PbbCommand, _Mapping]] = ..., fsb_command: _Optional[_Union[FsbCommand, _Mapping]] = ..., lrb_command: _Optional[_Union[LrbCommand, _Mapping]] = ...) -> None: ... + +class DmbCommand(_message.Message): + __slots__ = ("command_enum",) +class FcbCommand(_message.Message): + __slots__ = ["command_enum"] + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + RSC_FIRST_INVALID: _ClassVar[DmbCommand.Command] + RSC_ANY_TO_ABORT: _ClassVar[DmbCommand.Command] + RSC_OPEN_VENT: _ClassVar[DmbCommand.Command] + RSC_CLOSE_VENT: _ClassVar[DmbCommand.Command] + RSC_OPEN_DRAIN: _ClassVar[DmbCommand.Command] + RSC_CLOSE_DRAIN: _ClassVar[DmbCommand.Command] + RSC_MEV_CLOSE: _ClassVar[DmbCommand.Command] + RSC_GOTO_FILL: _ClassVar[DmbCommand.Command] + RSC_ARM_CONFIRM_1: _ClassVar[DmbCommand.Command] + RSC_ARM_CONFIRM_2: _ClassVar[DmbCommand.Command] + RSC_GOTO_ARM: _ClassVar[DmbCommand.Command] + RSC_GOTO_PRELAUNCH: _ClassVar[DmbCommand.Command] + RSC_POWER_TRANSITION_ONBOARD: _ClassVar[DmbCommand.Command] + RSC_POWER_TRANSITION_EXTERNAL: _ClassVar[DmbCommand.Command] + RSC_GOTO_IGNITION: _ClassVar[DmbCommand.Command] + RSC_IGNITION_TO_LAUNCH: _ClassVar[DmbCommand.Command] + RSC_LAUNCH_TO_BURN: _ClassVar[DmbCommand.Command] + RSC_BURN_TO_COAST: _ClassVar[DmbCommand.Command] + RSC_COAST_TO_DESCENT: _ClassVar[DmbCommand.Command] + RSC_DESCENT_TO_RECOVERY: _ClassVar[DmbCommand.Command] + RSC_GOTO_TEST: _ClassVar[DmbCommand.Command] + RSC_TEST_MEV_OPEN: _ClassVar[DmbCommand.Command] + RSC_TEST_MEV_ENABLE: _ClassVar[DmbCommand.Command] + RSC_TEST_MEV_DISABLE: _ClassVar[DmbCommand.Command] + RSC_NONE: _ClassVar[DmbCommand.Command] + RSC_FIRST_INVALID: DmbCommand.Command + RSC_ANY_TO_ABORT: DmbCommand.Command + RSC_OPEN_VENT: DmbCommand.Command + RSC_CLOSE_VENT: DmbCommand.Command + RSC_OPEN_DRAIN: DmbCommand.Command + RSC_CLOSE_DRAIN: DmbCommand.Command + RSC_MEV_CLOSE: DmbCommand.Command + RSC_GOTO_FILL: DmbCommand.Command + RSC_ARM_CONFIRM_1: DmbCommand.Command + RSC_ARM_CONFIRM_2: DmbCommand.Command + RSC_GOTO_ARM: DmbCommand.Command + RSC_GOTO_PRELAUNCH: DmbCommand.Command + RSC_POWER_TRANSITION_ONBOARD: DmbCommand.Command + RSC_POWER_TRANSITION_EXTERNAL: DmbCommand.Command + RSC_GOTO_IGNITION: DmbCommand.Command + RSC_IGNITION_TO_LAUNCH: DmbCommand.Command + RSC_LAUNCH_TO_BURN: DmbCommand.Command + RSC_BURN_TO_COAST: DmbCommand.Command + RSC_COAST_TO_DESCENT: DmbCommand.Command + RSC_DESCENT_TO_RECOVERY: DmbCommand.Command + RSC_GOTO_TEST: DmbCommand.Command + RSC_TEST_MEV_OPEN: DmbCommand.Command + RSC_TEST_MEV_ENABLE: DmbCommand.Command + RSC_TEST_MEV_DISABLE: DmbCommand.Command + RSC_NONE: DmbCommand.Command + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + command_enum: DmbCommand.Command + def __init__(self, command_enum: _Optional[_Union[DmbCommand.Command, str]] = ...) -> None: ... + __slots__ = [] + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + RSC_ANY_TO_ABORT: FcbCommand.Command + RSC_ARM_CONFIRM_1: FcbCommand.Command + RSC_ARM_CONFIRM_2: FcbCommand.Command + RSC_BURN_TO_COAST: FcbCommand.Command + RSC_CLOSE_DRAIN: FcbCommand.Command + RSC_CLOSE_VENT: FcbCommand.Command + RSC_COAST_TO_DESCENT: FcbCommand.Command + RSC_DESCENT_TO_RECOVERY: FcbCommand.Command + RSC_FIRST_INVALID: FcbCommand.Command + RSC_GOTO_ARM: FcbCommand.Command + RSC_GOTO_FILL: FcbCommand.Command + RSC_GOTO_IGNITION: FcbCommand.Command + RSC_GOTO_PRELAUNCH: FcbCommand.Command + RSC_GOTO_TEST: FcbCommand.Command + RSC_IGNITION_TO_LAUNCH: FcbCommand.Command + RSC_LAUNCH_TO_BURN: FcbCommand.Command + RSC_MEV_CLOSE: FcbCommand.Command + RSC_NONE: FcbCommand.Command + RSC_OPEN_DRAIN: FcbCommand.Command + RSC_OPEN_VENT: FcbCommand.Command + RSC_POWER_TRANSITION_EXTERNAL: FcbCommand.Command + RSC_POWER_TRANSITION_ONBOARD: FcbCommand.Command + RSC_TEST_MEV_DISABLE: FcbCommand.Command + RSC_TEST_MEV_ENABLE: FcbCommand.Command + RSC_TEST_MEV_OPEN: FcbCommand.Command + command_enum: FcbCommand.Command + def __init__(self, command_enum: _Optional[_Union[FcbCommand.Command, str]] = ...) -> None: ... + +class PbbCommand(_message.Message): + __slots__ = ("command_enum",) + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + PBB_NONE: _ClassVar[PbbCommand.Command] + PBB_OPEN_MEV: _ClassVar[PbbCommand.Command] + PBB_CLOSE_MEV: _ClassVar[PbbCommand.Command] + PMB_LAST: _ClassVar[PbbCommand.Command] + PBB_NONE: PbbCommand.Command + PBB_OPEN_MEV: PbbCommand.Command + PBB_CLOSE_MEV: PbbCommand.Command + PMB_LAST: PbbCommand.Command + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + command_enum: PbbCommand.Command + def __init__(self, command_enum: _Optional[_Union[PbbCommand.Command, str]] = ...) -> None: ... + +class SobCommand(_message.Message): + __slots__ = ("command_enum", "command_param") +class FsbCommand(_message.Message): + __slots__ = ["command_enum", "command_param"] + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + SOB_NONE: _ClassVar[SobCommand.Command] + SOB_SLOW_SAMPLE_IR: _ClassVar[SobCommand.Command] + SOB_FAST_SAMPLE_IR: _ClassVar[SobCommand.Command] + SOB_TARE_LOAD_CELL: _ClassVar[SobCommand.Command] + SOB_CALIBRATE_LOAD_CELL: _ClassVar[SobCommand.Command] + SOB_LAST: _ClassVar[SobCommand.Command] + SOB_NONE: SobCommand.Command + SOB_SLOW_SAMPLE_IR: SobCommand.Command + SOB_FAST_SAMPLE_IR: SobCommand.Command + SOB_TARE_LOAD_CELL: SobCommand.Command + SOB_CALIBRATE_LOAD_CELL: SobCommand.Command + SOB_LAST: SobCommand.Command + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + COMMAND_PARAM_FIELD_NUMBER: _ClassVar[int] + command_enum: SobCommand.Command + command_param: int + def __init__(self, command_enum: _Optional[_Union[SobCommand.Command, str]] = ..., command_param: _Optional[int] = ...) -> None: ... + +class RcuCommand(_message.Message): + __slots__ = ("command_enum", "command_param") + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + RCU_NONE: _ClassVar[RcuCommand.Command] + RCU_OPEN_AC1: _ClassVar[RcuCommand.Command] + RCU_CLOSE_AC1: _ClassVar[RcuCommand.Command] + RCU_OPEN_AC2: _ClassVar[RcuCommand.Command] + RCU_CLOSE_AC2: _ClassVar[RcuCommand.Command] + RCU_OPEN_PBV1: _ClassVar[RcuCommand.Command] + RCU_CLOSE_PBV1: _ClassVar[RcuCommand.Command] + RCU_OPEN_PBV2: _ClassVar[RcuCommand.Command] + RCU_CLOSE_PBV2: _ClassVar[RcuCommand.Command] + RCU_OPEN_PBV3: _ClassVar[RcuCommand.Command] + RCU_CLOSE_PBV3: _ClassVar[RcuCommand.Command] + RCU_OPEN_PBV4: _ClassVar[RcuCommand.Command] + RCU_CLOSE_PBV4: _ClassVar[RcuCommand.Command] + RCU_OPEN_SOL5: _ClassVar[RcuCommand.Command] + RCU_CLOSE_SOL5: _ClassVar[RcuCommand.Command] + RCU_OPEN_SOL6: _ClassVar[RcuCommand.Command] + RCU_CLOSE_SOL6: _ClassVar[RcuCommand.Command] + RCU_OPEN_SOL7: _ClassVar[RcuCommand.Command] + RCU_CLOSE_SOL7: _ClassVar[RcuCommand.Command] + RCU_OPEN_SOL8A: _ClassVar[RcuCommand.Command] + RCU_CLOSE_SOL8A: _ClassVar[RcuCommand.Command] + RCU_OPEN_SOL8B: _ClassVar[RcuCommand.Command] + RCU_CLOSE_SOL8B: _ClassVar[RcuCommand.Command] + RCU_TARE_NOS1_LOAD_CELL: _ClassVar[RcuCommand.Command] + RCU_TARE_NOS2_LOAD_CELL: _ClassVar[RcuCommand.Command] + RCU_CALIBRATE_NOS1_LOAD_CELL: _ClassVar[RcuCommand.Command] + RCU_CALIBRATE_NOS2_LOAD_CELL: _ClassVar[RcuCommand.Command] + RCU_IGNITE_PAD_BOX1: _ClassVar[RcuCommand.Command] + RCU_IGNITE_PAD_BOX2: _ClassVar[RcuCommand.Command] + RCU_KILL_PAD_BOX1: _ClassVar[RcuCommand.Command] + RCU_KILL_PAD_BOX2: _ClassVar[RcuCommand.Command] + RCU_LAST: _ClassVar[RcuCommand.Command] + RCU_NONE: RcuCommand.Command + RCU_OPEN_AC1: RcuCommand.Command + RCU_CLOSE_AC1: RcuCommand.Command + RCU_OPEN_AC2: RcuCommand.Command + RCU_CLOSE_AC2: RcuCommand.Command + RCU_OPEN_PBV1: RcuCommand.Command + RCU_CLOSE_PBV1: RcuCommand.Command + RCU_OPEN_PBV2: RcuCommand.Command + RCU_CLOSE_PBV2: RcuCommand.Command + RCU_OPEN_PBV3: RcuCommand.Command + RCU_CLOSE_PBV3: RcuCommand.Command + RCU_OPEN_PBV4: RcuCommand.Command + RCU_CLOSE_PBV4: RcuCommand.Command + RCU_OPEN_SOL5: RcuCommand.Command + RCU_CLOSE_SOL5: RcuCommand.Command + RCU_OPEN_SOL6: RcuCommand.Command + RCU_CLOSE_SOL6: RcuCommand.Command + RCU_OPEN_SOL7: RcuCommand.Command + RCU_CLOSE_SOL7: RcuCommand.Command + RCU_OPEN_SOL8A: RcuCommand.Command + RCU_CLOSE_SOL8A: RcuCommand.Command + RCU_OPEN_SOL8B: RcuCommand.Command + RCU_CLOSE_SOL8B: RcuCommand.Command + RCU_TARE_NOS1_LOAD_CELL: RcuCommand.Command + RCU_TARE_NOS2_LOAD_CELL: RcuCommand.Command + RCU_CALIBRATE_NOS1_LOAD_CELL: RcuCommand.Command + RCU_CALIBRATE_NOS2_LOAD_CELL: RcuCommand.Command + RCU_IGNITE_PAD_BOX1: RcuCommand.Command + RCU_IGNITE_PAD_BOX2: RcuCommand.Command + RCU_KILL_PAD_BOX1: RcuCommand.Command + RCU_KILL_PAD_BOX2: RcuCommand.Command + RCU_LAST: RcuCommand.Command + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + COMMAND_PARAM_FIELD_NUMBER: _ClassVar[int] + command_enum: RcuCommand.Command + RCU_CALIBRATE_NOS1_LOAD_CELL: FsbCommand.Command + RCU_CALIBRATE_NOS2_LOAD_CELL: FsbCommand.Command + RCU_CLOSE_AC1: FsbCommand.Command + RCU_CLOSE_AC2: FsbCommand.Command + RCU_CLOSE_PBV1: FsbCommand.Command + RCU_CLOSE_PBV2: FsbCommand.Command + RCU_CLOSE_PBV3: FsbCommand.Command + RCU_CLOSE_PBV4: FsbCommand.Command + RCU_CLOSE_SOL5: FsbCommand.Command + RCU_CLOSE_SOL6: FsbCommand.Command + RCU_CLOSE_SOL7: FsbCommand.Command + RCU_CLOSE_SOL8A: FsbCommand.Command + RCU_CLOSE_SOL8B: FsbCommand.Command + RCU_IGNITE_PAD_BOX1: FsbCommand.Command + RCU_IGNITE_PAD_BOX2: FsbCommand.Command + RCU_KILL_PAD_BOX1: FsbCommand.Command + RCU_KILL_PAD_BOX2: FsbCommand.Command + RCU_LAST: FsbCommand.Command + RCU_NONE: FsbCommand.Command + RCU_OPEN_AC1: FsbCommand.Command + RCU_OPEN_AC2: FsbCommand.Command + RCU_OPEN_PBV1: FsbCommand.Command + RCU_OPEN_PBV2: FsbCommand.Command + RCU_OPEN_PBV3: FsbCommand.Command + RCU_OPEN_PBV4: FsbCommand.Command + RCU_OPEN_SOL5: FsbCommand.Command + RCU_OPEN_SOL6: FsbCommand.Command + RCU_OPEN_SOL7: FsbCommand.Command + RCU_OPEN_SOL8A: FsbCommand.Command + RCU_OPEN_SOL8B: FsbCommand.Command + RCU_TARE_NOS1_LOAD_CELL: FsbCommand.Command + RCU_TARE_NOS2_LOAD_CELL: FsbCommand.Command + command_enum: FsbCommand.Command + command_param: int + def __init__(self, command_enum: _Optional[_Union[RcuCommand.Command, str]] = ..., command_param: _Optional[int] = ...) -> None: ... + def __init__(self, command_enum: _Optional[_Union[FsbCommand.Command, str]] = ..., command_param: _Optional[int] = ...) -> None: ... + +class LrbCommand(_message.Message): + __slots__ = ["command_enum", "command_param"] + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = [] + COMMAND_ENUM_FIELD_NUMBER: _ClassVar[int] + COMMAND_PARAM_FIELD_NUMBER: _ClassVar[int] + SOB_CALIBRATE_LOAD_CELL: LrbCommand.Command + SOB_FAST_SAMPLE_IR: LrbCommand.Command + SOB_LAST: LrbCommand.Command + SOB_NONE: LrbCommand.Command + SOB_SLOW_SAMPLE_IR: LrbCommand.Command + SOB_TARE_LOAD_CELL: LrbCommand.Command + command_enum: LrbCommand.Command + command_param: int + def __init__(self, command_enum: _Optional[_Union[LrbCommand.Command, str]] = ..., command_param: _Optional[int] = ...) -> None: ... diff --git a/SoarProto/_Python/CommandMessages_pb2.py b/SoarProto/_Python/CommandMessages_pb2.py new file mode 100644 index 0000000..5dd4d10 --- /dev/null +++ b/SoarProto/_Python/CommandMessages_pb2.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: CommandMessages.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x43ommandMessages.proto\x12\x05Proto\"c\n\x0f\x43ommandMessages\x12\x1b\n\x13source_sequence_num\x18\x01 \x01(\r\x12(\n\x0b\x66sb_command\x18\x02 \x01(\x0b\x32\x11.Proto.FsbCommandH\x00\x42\t\n\x07message\"|\n\nFsbCommand\x12.\n\x0b\x66sb_message\x18\x01 \x01(\x0e\x32\x19.Proto.FsbCommand.Command\">\n\x07\x43ommand\x12\x11\n\rSTART_LOGGING\x10\x00\x12\x10\n\x0cSTOP_LOGGING\x10\x01\x12\x0e\n\nSEND_FILES\x10\x02\x62\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'CommandMessages_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_COMMANDMESSAGES']._serialized_start=32 + _globals['_COMMANDMESSAGES']._serialized_end=131 + _globals['_FSBCOMMAND']._serialized_start=133 + _globals['_FSBCOMMAND']._serialized_end=257 + _globals['_FSBCOMMAND_COMMAND']._serialized_start=195 + _globals['_FSBCOMMAND_COMMAND']._serialized_end=257 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/CommandMessages_pb2.pyi b/SoarProto/_Python/CommandMessages_pb2.pyi new file mode 100644 index 0000000..07ecb89 --- /dev/null +++ b/SoarProto/_Python/CommandMessages_pb2.pyi @@ -0,0 +1,28 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class CommandMessages(_message.Message): + __slots__ = ("source_sequence_num", "fsb_command") + SOURCE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + FSB_COMMAND_FIELD_NUMBER: _ClassVar[int] + source_sequence_num: int + fsb_command: FsbCommand + def __init__(self, source_sequence_num: _Optional[int] = ..., fsb_command: _Optional[_Union[FsbCommand, _Mapping]] = ...) -> None: ... + +class FsbCommand(_message.Message): + __slots__ = ("fsb_message",) + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + START_LOGGING: _ClassVar[FsbCommand.Command] + STOP_LOGGING: _ClassVar[FsbCommand.Command] + SEND_FILES: _ClassVar[FsbCommand.Command] + START_LOGGING: FsbCommand.Command + STOP_LOGGING: FsbCommand.Command + SEND_FILES: FsbCommand.Command + FSB_MESSAGE_FIELD_NUMBER: _ClassVar[int] + fsb_message: FsbCommand.Command + def __init__(self, fsb_message: _Optional[_Union[FsbCommand.Command, str]] = ...) -> None: ... diff --git a/SoarProto/_Python/ControlMessage_pb2.py b/SoarProto/_Python/ControlMessage_pb2.py new file mode 100644 index 0000000..d188709 --- /dev/null +++ b/SoarProto/_Python/ControlMessage_pb2.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: ControlMessage.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +import CoreProto_pb2 as CoreProto__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x14\x43ontrolMessage.proto\x12\x05Proto\x1a\x0f\x43oreProto.proto\"\x90\x03\n\x0e\x43ontrolMessage\x12\x1b\n\x06source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x06target\x18\x02 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x13source_sequence_num\x18\x04 \x01(\r\x12\x1d\n\x03\x61\x63k\x18\x05 \x01(\x0b\x32\x0e.Proto.AckNackH\x00\x12\x1e\n\x04nack\x18\x06 \x01(\x0b\x32\x0e.Proto.AckNackH\x00\x12\x1b\n\x04ping\x18\x07 \x01(\x0b\x32\x0b.Proto.PingH\x00\x12\x1e\n\x02hb\x18\x08 \x01(\x0b\x32\x10.Proto.HeartbeatH\x00\x12\'\n\tsys_state\x18\t \x01(\x0b\x32\x12.Proto.SystemStateH\x00\x12(\n\x08sys_ctrl\x18\n \x01(\x0b\x32\x14.Proto.SystemControlH\x00\x12)\n\x08hb_state\x18\x0b \x01(\x0b\x32\x15.Proto.HeartbeatStateH\x00\x12\"\n\x08\x66\x61st_log\x18\x0c \x01(\x0b\x32\x0e.Proto.FastLogH\x00\x42\t\n\x07message\"w\n\x07\x41\x63kNack\x12&\n\x11\x61\x63king_msg_source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\'\n\racking_msg_id\x18\x02 \x01(\x0e\x32\x10.Proto.MessageID\x12\x1b\n\x13\x61\x63king_sequence_num\x18\x03 \x01(\r\"d\n\x04Ping\x12\x13\n\x0bping_ack_id\x18\x01 \x01(\r\x12\"\n\x1aping_response_sequence_num\x18\x02 \x01(\r\x12#\n\x1bsys_state_response_required\x18\x03 \x01(\x08\"-\n\tHeartbeat\x12 \n\x18hb_response_sequence_num\x18\x01 \x01(\r\"\xc4\x02\n\x0bSystemState\x12+\n\tsys_state\x18\x01 \x01(\x0e\x32\x18.Proto.SystemState.State\x12-\n\x0crocket_state\x18\x02 \x01(\x0e\x32\x12.Proto.RocketStateH\x00\x88\x01\x01\"\xc7\x01\n\x05State\x12\x0f\n\x0bSYS_INVALID\x10\x00\x12\x17\n\x13SYS_BOOTUP_COMPLETE\x10\x01\x12\x1c\n\x18SYS_ASSERT_FAILURE_RESET\x10\x02\x12\x16\n\x12SYS_UNCAUGHT_RESET\x10\x03\x12\x18\n\x14SYS_NORMAL_OPERATION\x10\x04\x12#\n\x1fSYS_HEARTBEAT_LOSS_HALF_WARNING\x10\x05\x12\x1f\n\x1bSYS_HEARTBEAT_LOST_ABORTING\x10\x06\x42\x0f\n\r_rocket_state\"\xb2\x02\n\rSystemControl\x12-\n\x07sys_cmd\x18\x01 \x01(\x0e\x32\x1c.Proto.SystemControl.Command\x12\x11\n\tcmd_param\x18\x02 \x01(\r\"\xde\x01\n\x07\x43ommand\x12\x0f\n\x0bSYS_INVALID\x10\x00\x12\r\n\tSYS_RESET\x10\x01\x12\x13\n\x0fSYS_FLASH_ERASE\x10\x02\x12\x19\n\x15SYS_LOG_PERIOD_CHANGE\x10\x03\x12\x14\n\x10HEARTBEAT_ENABLE\x10\x04\x12\x15\n\x11HEARTBEAT_DISABLE\x10\x05\x12\x18\n\x14SYS_FLASH_LOG_ENABLE\x10\x06\x12\x19\n\x15SYS_FLASH_LOG_DISABLE\x10\x07\x12!\n\x1dSYS_CRITICAL_FLASH_FULL_ERASE\x10\x08\"\xbf\x01\n\x0eHeartbeatState\x12\x35\n\x0btimer_state\x18\x01 \x01(\x0e\x32 .Proto.HeartbeatState.TimerState\x12\x14\n\x0ctimer_period\x18\x02 \x01(\r\x12\x17\n\x0ftimer_remaining\x18\x03 \x01(\r\"G\n\nTimerState\x12\x11\n\rUNINITIALIZED\x10\x00\x12\x0c\n\x08\x43OUNTING\x10\x01\x12\n\n\x06PAUSED\x10\x02\x12\x0c\n\x08\x43OMPLETE\x10\x03\"}\n\x07\x46\x61stLog\x12*\n\x03\x63md\x18\x01 \x01(\x0e\x32\x1d.Proto.FastLog.FastLogCommand\"F\n\x0e\x46\x61stLogCommand\x12\x0b\n\x07\x46L_PEND\x10\x00\x12\x0c\n\x08\x46L_START\x10\x01\x12\x0b\n\x07\x46L_SEND\x10\x02\x12\x0c\n\x08\x46L_RESET\x10\x03\x62\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'ControlMessage_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_CONTROLMESSAGE']._serialized_start=49 + _globals['_CONTROLMESSAGE']._serialized_end=449 + _globals['_ACKNACK']._serialized_start=451 + _globals['_ACKNACK']._serialized_end=570 + _globals['_PING']._serialized_start=572 + _globals['_PING']._serialized_end=672 + _globals['_HEARTBEAT']._serialized_start=674 + _globals['_HEARTBEAT']._serialized_end=719 + _globals['_SYSTEMSTATE']._serialized_start=722 + _globals['_SYSTEMSTATE']._serialized_end=1046 + _globals['_SYSTEMSTATE_STATE']._serialized_start=830 + _globals['_SYSTEMSTATE_STATE']._serialized_end=1029 + _globals['_SYSTEMCONTROL']._serialized_start=1049 + _globals['_SYSTEMCONTROL']._serialized_end=1355 + _globals['_SYSTEMCONTROL_COMMAND']._serialized_start=1133 + _globals['_SYSTEMCONTROL_COMMAND']._serialized_end=1355 + _globals['_HEARTBEATSTATE']._serialized_start=1358 + _globals['_HEARTBEATSTATE']._serialized_end=1549 + _globals['_HEARTBEATSTATE_TIMERSTATE']._serialized_start=1478 + _globals['_HEARTBEATSTATE_TIMERSTATE']._serialized_end=1549 + _globals['_FASTLOG']._serialized_start=1551 + _globals['_FASTLOG']._serialized_end=1676 + _globals['_FASTLOG_FASTLOGCOMMAND']._serialized_start=1606 + _globals['_FASTLOG_FASTLOGCOMMAND']._serialized_end=1676 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/ControlMessage_pb2.pyi b/SoarProto/_Python/ControlMessage_pb2.pyi new file mode 100644 index 0000000..dddbeea --- /dev/null +++ b/SoarProto/_Python/ControlMessage_pb2.pyi @@ -0,0 +1,147 @@ +import CoreProto_pb2 as _CoreProto_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class ControlMessage(_message.Message): + __slots__ = ("source", "target", "source_sequence_num", "ack", "nack", "ping", "hb", "sys_state", "sys_ctrl", "hb_state", "fast_log") + SOURCE_FIELD_NUMBER: _ClassVar[int] + TARGET_FIELD_NUMBER: _ClassVar[int] + SOURCE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + ACK_FIELD_NUMBER: _ClassVar[int] + NACK_FIELD_NUMBER: _ClassVar[int] + PING_FIELD_NUMBER: _ClassVar[int] + HB_FIELD_NUMBER: _ClassVar[int] + SYS_STATE_FIELD_NUMBER: _ClassVar[int] + SYS_CTRL_FIELD_NUMBER: _ClassVar[int] + HB_STATE_FIELD_NUMBER: _ClassVar[int] + FAST_LOG_FIELD_NUMBER: _ClassVar[int] + source: _CoreProto_pb2.Node + target: _CoreProto_pb2.Node + source_sequence_num: int + ack: AckNack + nack: AckNack + ping: Ping + hb: Heartbeat + sys_state: SystemState + sys_ctrl: SystemControl + hb_state: HeartbeatState + fast_log: FastLog + def __init__(self, source: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., target: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., source_sequence_num: _Optional[int] = ..., ack: _Optional[_Union[AckNack, _Mapping]] = ..., nack: _Optional[_Union[AckNack, _Mapping]] = ..., ping: _Optional[_Union[Ping, _Mapping]] = ..., hb: _Optional[_Union[Heartbeat, _Mapping]] = ..., sys_state: _Optional[_Union[SystemState, _Mapping]] = ..., sys_ctrl: _Optional[_Union[SystemControl, _Mapping]] = ..., hb_state: _Optional[_Union[HeartbeatState, _Mapping]] = ..., fast_log: _Optional[_Union[FastLog, _Mapping]] = ...) -> None: ... + +class AckNack(_message.Message): + __slots__ = ("acking_msg_source", "acking_msg_id", "acking_sequence_num") + ACKING_MSG_SOURCE_FIELD_NUMBER: _ClassVar[int] + ACKING_MSG_ID_FIELD_NUMBER: _ClassVar[int] + ACKING_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + acking_msg_source: _CoreProto_pb2.Node + acking_msg_id: _CoreProto_pb2.MessageID + acking_sequence_num: int + def __init__(self, acking_msg_source: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., acking_msg_id: _Optional[_Union[_CoreProto_pb2.MessageID, str]] = ..., acking_sequence_num: _Optional[int] = ...) -> None: ... + +class Ping(_message.Message): + __slots__ = ("ping_ack_id", "ping_response_sequence_num", "sys_state_response_required") + PING_ACK_ID_FIELD_NUMBER: _ClassVar[int] + PING_RESPONSE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + SYS_STATE_RESPONSE_REQUIRED_FIELD_NUMBER: _ClassVar[int] + ping_ack_id: int + ping_response_sequence_num: int + sys_state_response_required: bool + def __init__(self, ping_ack_id: _Optional[int] = ..., ping_response_sequence_num: _Optional[int] = ..., sys_state_response_required: bool = ...) -> None: ... + +class Heartbeat(_message.Message): + __slots__ = ("hb_response_sequence_num",) + HB_RESPONSE_SEQUENCE_NUM_FIELD_NUMBER: _ClassVar[int] + hb_response_sequence_num: int + def __init__(self, hb_response_sequence_num: _Optional[int] = ...) -> None: ... + +class SystemState(_message.Message): + __slots__ = ("sys_state", "rocket_state") + class State(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + SYS_INVALID: _ClassVar[SystemState.State] + SYS_BOOTUP_COMPLETE: _ClassVar[SystemState.State] + SYS_ASSERT_FAILURE_RESET: _ClassVar[SystemState.State] + SYS_UNCAUGHT_RESET: _ClassVar[SystemState.State] + SYS_NORMAL_OPERATION: _ClassVar[SystemState.State] + SYS_HEARTBEAT_LOSS_HALF_WARNING: _ClassVar[SystemState.State] + SYS_HEARTBEAT_LOST_ABORTING: _ClassVar[SystemState.State] + SYS_INVALID: SystemState.State + SYS_BOOTUP_COMPLETE: SystemState.State + SYS_ASSERT_FAILURE_RESET: SystemState.State + SYS_UNCAUGHT_RESET: SystemState.State + SYS_NORMAL_OPERATION: SystemState.State + SYS_HEARTBEAT_LOSS_HALF_WARNING: SystemState.State + SYS_HEARTBEAT_LOST_ABORTING: SystemState.State + SYS_STATE_FIELD_NUMBER: _ClassVar[int] + ROCKET_STATE_FIELD_NUMBER: _ClassVar[int] + sys_state: SystemState.State + rocket_state: _CoreProto_pb2.RocketState + def __init__(self, sys_state: _Optional[_Union[SystemState.State, str]] = ..., rocket_state: _Optional[_Union[_CoreProto_pb2.RocketState, str]] = ...) -> None: ... + +class SystemControl(_message.Message): + __slots__ = ("sys_cmd", "cmd_param") + class Command(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + SYS_INVALID: _ClassVar[SystemControl.Command] + SYS_RESET: _ClassVar[SystemControl.Command] + SYS_FLASH_ERASE: _ClassVar[SystemControl.Command] + SYS_LOG_PERIOD_CHANGE: _ClassVar[SystemControl.Command] + HEARTBEAT_ENABLE: _ClassVar[SystemControl.Command] + HEARTBEAT_DISABLE: _ClassVar[SystemControl.Command] + SYS_FLASH_LOG_ENABLE: _ClassVar[SystemControl.Command] + SYS_FLASH_LOG_DISABLE: _ClassVar[SystemControl.Command] + SYS_CRITICAL_FLASH_FULL_ERASE: _ClassVar[SystemControl.Command] + SYS_INVALID: SystemControl.Command + SYS_RESET: SystemControl.Command + SYS_FLASH_ERASE: SystemControl.Command + SYS_LOG_PERIOD_CHANGE: SystemControl.Command + HEARTBEAT_ENABLE: SystemControl.Command + HEARTBEAT_DISABLE: SystemControl.Command + SYS_FLASH_LOG_ENABLE: SystemControl.Command + SYS_FLASH_LOG_DISABLE: SystemControl.Command + SYS_CRITICAL_FLASH_FULL_ERASE: SystemControl.Command + SYS_CMD_FIELD_NUMBER: _ClassVar[int] + CMD_PARAM_FIELD_NUMBER: _ClassVar[int] + sys_cmd: SystemControl.Command + cmd_param: int + def __init__(self, sys_cmd: _Optional[_Union[SystemControl.Command, str]] = ..., cmd_param: _Optional[int] = ...) -> None: ... + +class HeartbeatState(_message.Message): + __slots__ = ("timer_state", "timer_period", "timer_remaining") + class TimerState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + UNINITIALIZED: _ClassVar[HeartbeatState.TimerState] + COUNTING: _ClassVar[HeartbeatState.TimerState] + PAUSED: _ClassVar[HeartbeatState.TimerState] + COMPLETE: _ClassVar[HeartbeatState.TimerState] + UNINITIALIZED: HeartbeatState.TimerState + COUNTING: HeartbeatState.TimerState + PAUSED: HeartbeatState.TimerState + COMPLETE: HeartbeatState.TimerState + TIMER_STATE_FIELD_NUMBER: _ClassVar[int] + TIMER_PERIOD_FIELD_NUMBER: _ClassVar[int] + TIMER_REMAINING_FIELD_NUMBER: _ClassVar[int] + timer_state: HeartbeatState.TimerState + timer_period: int + timer_remaining: int + def __init__(self, timer_state: _Optional[_Union[HeartbeatState.TimerState, str]] = ..., timer_period: _Optional[int] = ..., timer_remaining: _Optional[int] = ...) -> None: ... + +class FastLog(_message.Message): + __slots__ = ("cmd",) + class FastLogCommand(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + FL_PEND: _ClassVar[FastLog.FastLogCommand] + FL_START: _ClassVar[FastLog.FastLogCommand] + FL_SEND: _ClassVar[FastLog.FastLogCommand] + FL_RESET: _ClassVar[FastLog.FastLogCommand] + FL_PEND: FastLog.FastLogCommand + FL_START: FastLog.FastLogCommand + FL_SEND: FastLog.FastLogCommand + FL_RESET: FastLog.FastLogCommand + CMD_FIELD_NUMBER: _ClassVar[int] + cmd: FastLog.FastLogCommand + def __init__(self, cmd: _Optional[_Union[FastLog.FastLogCommand, str]] = ...) -> None: ... diff --git a/SoarProto/_Python/CoreProto_pb2.py b/SoarProto/_Python/CoreProto_pb2.py new file mode 100644 index 0000000..aa5e16a --- /dev/null +++ b/SoarProto/_Python/CoreProto_pb2.py @@ -0,0 +1,30 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: CoreProto.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0f\x43oreProto.proto\x12\x05Proto*p\n\x04Node\x12\x10\n\x0cNODE_INVALID\x10\x00\x12\x10\n\x0cNODE_UNKNOWN\x10\x01\x12\x0c\n\x08NODE_ANY\x10\x02\x12\x0c\n\x08NODE_RCU\x10\x03\x12\x0c\n\x08NODE_DMB\x10\x04\x12\x0c\n\x08NODE_PBB\x10\x05\x12\x0c\n\x08NODE_SOB\x10\x06*w\n\tMessageID\x12\x0f\n\x0bMSG_INVALID\x10\x00\x12\x0f\n\x0bMSG_UNKNOWN\x10\x01\x12\x0f\n\x0bMSG_CONTROL\x10\x02\x12\x0f\n\x0bMSG_COMMAND\x10\x03\x12\x11\n\rMSG_TELEMETRY\x10\x04\x12\x13\n\x0fMSG_MAX_INVALID\x10\x05*\xcd\x01\n\x0bRocketState\x12\x0f\n\x0b\x44MB_INVALID\x10\x00\x12\x10\n\x0cRS_PRELAUNCH\x10\x01\x12\x0b\n\x07RS_FILL\x10\x02\x12\n\n\x06RS_ARM\x10\x03\x12\x0f\n\x0bRS_IGNITION\x10\x04\x12\r\n\tRS_LAUNCH\x10\x05\x12\x0b\n\x07RS_BURN\x10\x06\x12\x0c\n\x08RS_COAST\x10\x07\x12\x0e\n\nRS_DESCENT\x10\x08\x12\x0f\n\x0bRS_RECOVERY\x10\t\x12\x0c\n\x08RS_ABORT\x10\n\x12\x0b\n\x07RS_TEST\x10\x0b\x12\x0b\n\x07RS_NONE\x10\x0c\x62\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'CoreProto_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_NODE']._serialized_start=26 + _globals['_NODE']._serialized_end=138 + _globals['_MESSAGEID']._serialized_start=140 + _globals['_MESSAGEID']._serialized_end=259 + _globals['_ROCKETSTATE']._serialized_start=262 + _globals['_ROCKETSTATE']._serialized_end=467 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/CoreProto_pb2.pyi b/SoarProto/_Python/CoreProto_pb2.pyi new file mode 100644 index 0000000..f3e32f5 --- /dev/null +++ b/SoarProto/_Python/CoreProto_pb2.pyi @@ -0,0 +1,66 @@ +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from typing import ClassVar as _ClassVar + +DESCRIPTOR: _descriptor.FileDescriptor + +class Node(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + NODE_INVALID: _ClassVar[Node] + NODE_UNKNOWN: _ClassVar[Node] + NODE_ANY: _ClassVar[Node] + NODE_RCU: _ClassVar[Node] + NODE_DMB: _ClassVar[Node] + NODE_PBB: _ClassVar[Node] + NODE_SOB: _ClassVar[Node] + +class MessageID(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + MSG_INVALID: _ClassVar[MessageID] + MSG_UNKNOWN: _ClassVar[MessageID] + MSG_CONTROL: _ClassVar[MessageID] + MSG_COMMAND: _ClassVar[MessageID] + MSG_TELEMETRY: _ClassVar[MessageID] + MSG_MAX_INVALID: _ClassVar[MessageID] + +class RocketState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + DMB_INVALID: _ClassVar[RocketState] + RS_PRELAUNCH: _ClassVar[RocketState] + RS_FILL: _ClassVar[RocketState] + RS_ARM: _ClassVar[RocketState] + RS_IGNITION: _ClassVar[RocketState] + RS_LAUNCH: _ClassVar[RocketState] + RS_BURN: _ClassVar[RocketState] + RS_COAST: _ClassVar[RocketState] + RS_DESCENT: _ClassVar[RocketState] + RS_RECOVERY: _ClassVar[RocketState] + RS_ABORT: _ClassVar[RocketState] + RS_TEST: _ClassVar[RocketState] + RS_NONE: _ClassVar[RocketState] +NODE_INVALID: Node +NODE_UNKNOWN: Node +NODE_ANY: Node +NODE_RCU: Node +NODE_DMB: Node +NODE_PBB: Node +NODE_SOB: Node +MSG_INVALID: MessageID +MSG_UNKNOWN: MessageID +MSG_CONTROL: MessageID +MSG_COMMAND: MessageID +MSG_TELEMETRY: MessageID +MSG_MAX_INVALID: MessageID +DMB_INVALID: RocketState +RS_PRELAUNCH: RocketState +RS_FILL: RocketState +RS_ARM: RocketState +RS_IGNITION: RocketState +RS_LAUNCH: RocketState +RS_BURN: RocketState +RS_COAST: RocketState +RS_DESCENT: RocketState +RS_RECOVERY: RocketState +RS_ABORT: RocketState +RS_TEST: RocketState +RS_NONE: RocketState diff --git a/SoarProto/_Python/SensorData_pb2.py b/SoarProto/_Python/SensorData_pb2.py new file mode 100644 index 0000000..242be8c --- /dev/null +++ b/SoarProto/_Python/SensorData_pb2.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: SensorData.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10SensorData.proto\x12\x05Proto\"\xa5\x02\n\nSensorData\x12\x11\n\ttimestamp\x18\x01 \x01(\r\x12,\n\x10\x62\x61rometerMessage\x18\x02 \x01(\x0b\x32\x10.Proto.BarometerH\x00\x12\x34\n\x14\x61\x63\x63\x65lerometerMessage\x18\x03 \x01(\x0b\x32\x14.Proto.AccelerometerH\x00\x12\x32\n\x13magnetometerMessage\x18\x04 \x01(\x0b\x32\x13.Proto.MagnetometerH\x00\x12-\n\x11gyroscoperMessage\x18\x05 \x01(\x0b\x32\x10.Proto.GyroscopeH\x00\x12\x32\n\x13thermocoupleMessage\x18\x06 \x01(\x0b\x32\x13.Proto.ThermocoupleH\x00\x42\t\n\x07message\"\x85\x01\n\tBarometer\x12\x15\n\rbaro_pressure\x18\x01 \x01(\x05\x12\x18\n\x10\x62\x61ro_temperature\x18\x02 \x01(\x05\x12\x33\n\x11sensorLoggingRate\x18\x03 \x01(\x0b\x32\x18.Proto.SensorLoggingRate\x12\x12\n\nLoggingIdx\x18\x04 \x01(\x05\"\x8b\x01\n\rAccelerometer\x12\x0f\n\x07\x61\x63\x63\x65l_x\x18\x01 \x01(\x05\x12\x0f\n\x07\x61\x63\x63\x65l_y\x18\x02 \x01(\x05\x12\x0f\n\x07\x61\x63\x63\x65l_z\x18\x03 \x01(\x05\x12\x33\n\x11sensorLoggingRate\x18\x04 \x01(\x0b\x32\x18.Proto.SensorLoggingRate\x12\x12\n\nLoggingIdx\x18\x05 \x01(\x05\"\x84\x01\n\x0cMagnetometer\x12\r\n\x05mag_x\x18\x01 \x01(\x05\x12\r\n\x05mag_y\x18\x02 \x01(\x05\x12\r\n\x05mag_z\x18\x03 \x01(\x05\x12\x33\n\x11sensorLoggingRate\x18\x04 \x01(\x0b\x32\x18.Proto.SensorLoggingRate\x12\x12\n\nLoggingIdx\x18\x05 \x01(\x05\"\x84\x01\n\tGyroscope\x12\x0e\n\x06gyro_x\x18\x01 \x01(\x05\x12\x0e\n\x06gyro_y\x18\x02 \x01(\x05\x12\x0e\n\x06gyro_z\x18\x03 \x01(\x05\x12\x33\n\x11sensorLoggingRate\x18\x04 \x01(\x0b\x32\x18.Proto.SensorLoggingRate\x12\x12\n\nLoggingIdx\x18\x05 \x01(\x05\"r\n\x0cThermocouple\x12\x19\n\x11termo_temperature\x18\x01 \x01(\x05\x12\x33\n\x11sensorLoggingRate\x18\x02 \x01(\x0b\x32\x18.Proto.SensorLoggingRate\x12\x12\n\nLoggingIdx\x18\x03 \x01(\x05\"L\n\x11SensorLoggingRate\x12\x19\n\x11\x63hangeLoggingRate\x18\x01 \x01(\x08\x12\x1c\n\x14newSensorLoggingRate\x18\x02 \x01(\rb\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'SensorData_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_SENSORDATA']._serialized_start=28 + _globals['_SENSORDATA']._serialized_end=321 + _globals['_BAROMETER']._serialized_start=324 + _globals['_BAROMETER']._serialized_end=457 + _globals['_ACCELEROMETER']._serialized_start=460 + _globals['_ACCELEROMETER']._serialized_end=599 + _globals['_MAGNETOMETER']._serialized_start=602 + _globals['_MAGNETOMETER']._serialized_end=734 + _globals['_GYROSCOPE']._serialized_start=737 + _globals['_GYROSCOPE']._serialized_end=869 + _globals['_THERMOCOUPLE']._serialized_start=871 + _globals['_THERMOCOUPLE']._serialized_end=985 + _globals['_SENSORLOGGINGRATE']._serialized_start=987 + _globals['_SENSORLOGGINGRATE']._serialized_end=1063 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/SensorData_pb2.pyi b/SoarProto/_Python/SensorData_pb2.pyi new file mode 100644 index 0000000..166d64a --- /dev/null +++ b/SoarProto/_Python/SensorData_pb2.pyi @@ -0,0 +1,93 @@ +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class SensorData(_message.Message): + __slots__ = ("timestamp", "barometerMessage", "accelerometerMessage", "magnetometerMessage", "gyroscoperMessage", "thermocoupleMessage") + TIMESTAMP_FIELD_NUMBER: _ClassVar[int] + BAROMETERMESSAGE_FIELD_NUMBER: _ClassVar[int] + ACCELEROMETERMESSAGE_FIELD_NUMBER: _ClassVar[int] + MAGNETOMETERMESSAGE_FIELD_NUMBER: _ClassVar[int] + GYROSCOPERMESSAGE_FIELD_NUMBER: _ClassVar[int] + THERMOCOUPLEMESSAGE_FIELD_NUMBER: _ClassVar[int] + timestamp: int + barometerMessage: Barometer + accelerometerMessage: Accelerometer + magnetometerMessage: Magnetometer + gyroscoperMessage: Gyroscope + thermocoupleMessage: Thermocouple + def __init__(self, timestamp: _Optional[int] = ..., barometerMessage: _Optional[_Union[Barometer, _Mapping]] = ..., accelerometerMessage: _Optional[_Union[Accelerometer, _Mapping]] = ..., magnetometerMessage: _Optional[_Union[Magnetometer, _Mapping]] = ..., gyroscoperMessage: _Optional[_Union[Gyroscope, _Mapping]] = ..., thermocoupleMessage: _Optional[_Union[Thermocouple, _Mapping]] = ...) -> None: ... + +class Barometer(_message.Message): + __slots__ = ("baro_pressure", "baro_temperature", "sensorLoggingRate", "LoggingIdx") + BARO_PRESSURE_FIELD_NUMBER: _ClassVar[int] + BARO_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + SENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + LOGGINGIDX_FIELD_NUMBER: _ClassVar[int] + baro_pressure: int + baro_temperature: int + sensorLoggingRate: SensorLoggingRate + LoggingIdx: int + def __init__(self, baro_pressure: _Optional[int] = ..., baro_temperature: _Optional[int] = ..., sensorLoggingRate: _Optional[_Union[SensorLoggingRate, _Mapping]] = ..., LoggingIdx: _Optional[int] = ...) -> None: ... + +class Accelerometer(_message.Message): + __slots__ = ("accel_x", "accel_y", "accel_z", "sensorLoggingRate", "LoggingIdx") + ACCEL_X_FIELD_NUMBER: _ClassVar[int] + ACCEL_Y_FIELD_NUMBER: _ClassVar[int] + ACCEL_Z_FIELD_NUMBER: _ClassVar[int] + SENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + LOGGINGIDX_FIELD_NUMBER: _ClassVar[int] + accel_x: int + accel_y: int + accel_z: int + sensorLoggingRate: SensorLoggingRate + LoggingIdx: int + def __init__(self, accel_x: _Optional[int] = ..., accel_y: _Optional[int] = ..., accel_z: _Optional[int] = ..., sensorLoggingRate: _Optional[_Union[SensorLoggingRate, _Mapping]] = ..., LoggingIdx: _Optional[int] = ...) -> None: ... + +class Magnetometer(_message.Message): + __slots__ = ("mag_x", "mag_y", "mag_z", "sensorLoggingRate", "LoggingIdx") + MAG_X_FIELD_NUMBER: _ClassVar[int] + MAG_Y_FIELD_NUMBER: _ClassVar[int] + MAG_Z_FIELD_NUMBER: _ClassVar[int] + SENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + LOGGINGIDX_FIELD_NUMBER: _ClassVar[int] + mag_x: int + mag_y: int + mag_z: int + sensorLoggingRate: SensorLoggingRate + LoggingIdx: int + def __init__(self, mag_x: _Optional[int] = ..., mag_y: _Optional[int] = ..., mag_z: _Optional[int] = ..., sensorLoggingRate: _Optional[_Union[SensorLoggingRate, _Mapping]] = ..., LoggingIdx: _Optional[int] = ...) -> None: ... + +class Gyroscope(_message.Message): + __slots__ = ("gyro_x", "gyro_y", "gyro_z", "sensorLoggingRate", "LoggingIdx") + GYRO_X_FIELD_NUMBER: _ClassVar[int] + GYRO_Y_FIELD_NUMBER: _ClassVar[int] + GYRO_Z_FIELD_NUMBER: _ClassVar[int] + SENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + LOGGINGIDX_FIELD_NUMBER: _ClassVar[int] + gyro_x: int + gyro_y: int + gyro_z: int + sensorLoggingRate: SensorLoggingRate + LoggingIdx: int + def __init__(self, gyro_x: _Optional[int] = ..., gyro_y: _Optional[int] = ..., gyro_z: _Optional[int] = ..., sensorLoggingRate: _Optional[_Union[SensorLoggingRate, _Mapping]] = ..., LoggingIdx: _Optional[int] = ...) -> None: ... + +class Thermocouple(_message.Message): + __slots__ = ("termo_temperature", "sensorLoggingRate", "LoggingIdx") + TERMO_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + SENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + LOGGINGIDX_FIELD_NUMBER: _ClassVar[int] + termo_temperature: int + sensorLoggingRate: SensorLoggingRate + LoggingIdx: int + def __init__(self, termo_temperature: _Optional[int] = ..., sensorLoggingRate: _Optional[_Union[SensorLoggingRate, _Mapping]] = ..., LoggingIdx: _Optional[int] = ...) -> None: ... + +class SensorLoggingRate(_message.Message): + __slots__ = ("changeLoggingRate", "newSensorLoggingRate") + CHANGELOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + NEWSENSORLOGGINGRATE_FIELD_NUMBER: _ClassVar[int] + changeLoggingRate: bool + newSensorLoggingRate: int + def __init__(self, changeLoggingRate: bool = ..., newSensorLoggingRate: _Optional[int] = ...) -> None: ... diff --git a/SoarProto/_Python/TelemetryMessage_pb2.py b/SoarProto/_Python/TelemetryMessage_pb2.py new file mode 100644 index 0000000..a084fb1 --- /dev/null +++ b/SoarProto/_Python/TelemetryMessage_pb2.py @@ -0,0 +1,67 @@ +# -*- coding: utf-8 -*- +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: TelemetryMessage.proto +# Protobuf Python Version: 4.25.0 +"""Generated protocol buffer code.""" +from google.protobuf import descriptor as _descriptor +from google.protobuf import descriptor_pool as _descriptor_pool +from google.protobuf import symbol_database as _symbol_database +from google.protobuf.internal import builder as _builder +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +import CoreProto_pb2 as CoreProto__pb2 + + +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16TelemetryMessage.proto\x12\x05Proto\x1a\x0f\x43oreProto.proto\"\xaf\x06\n\x10TelemetryMessage\x12\x1b\n\x06source\x18\x01 \x01(\x0e\x32\x0b.Proto.Node\x12\x1b\n\x06target\x18\x02 \x01(\x0e\x32\x0b.Proto.Node\x12\x19\n\x03gps\x18\x03 \x01(\x0b\x32\n.Proto.GpsH\x00\x12\x1b\n\x04\x62\x61ro\x18\x04 \x01(\x0b\x32\x0b.Proto.BaroH\x00\x12\x19\n\x03imu\x18\x05 \x01(\x0b\x32\n.Proto.ImuH\x00\x12!\n\x07\x62\x61ttery\x18\x06 \x01(\x0b\x32\x0e.Proto.BatteryH\x00\x12\"\n\nflashState\x18\x07 \x01(\x0b\x32\x0c.Proto.FlashH\x00\x12)\n\x0b\x64mbPressure\x18\x08 \x01(\x0b\x32\x12.Proto.DmbPressureH\x00\x12)\n\x0bpbbPressure\x18\t \x01(\x0b\x32\x12.Proto.PbbPressureH\x00\x12/\n\x0epbbTemperature\x18\n \x01(\x0b\x32\x15.Proto.PbbTemperatureH\x00\x12\x41\n\x17\x63ombustionControlStatus\x18\x0b \x01(\x0b\x32\x1e.Proto.CombustionControlStatusH\x00\x12)\n\x0brcuPressure\x18\x0c \x01(\x0b\x32\x12.Proto.RcuPressureH\x00\x12/\n\x0ercuTemperature\x18\r \x01(\x0b\x32\x15.Proto.RcuTemperatureH\x00\x12)\n\x0bnosLoadCell\x18\x0e \x01(\x0b\x32\x12.Proto.NosLoadCellH\x00\x12)\n\x0brelayStatus\x18\x0f \x01(\x0b\x32\x12.Proto.RelayStatusH\x00\x12+\n\x0cpadBoxStatus\x18\x10 \x01(\x0b\x32\x13.Proto.PadBoxStatusH\x00\x12\x37\n\x12launchRailLoadCell\x18\x11 \x01(\x0b\x32\x19.Proto.LaunchRailLoadCellH\x00\x12/\n\x0esobTemperature\x18\x12 \x01(\x0b\x32\x15.Proto.SobTemperatureH\x00\x12)\n\x0bpressureLog\x18\x13 \x01(\x0b\x32\x12.Proto.PressureLogH\x00\x42\t\n\x07message\"\xf0\x01\n\x03Gps\x12\'\n\x08latitude\x18\x01 \x01(\x0b\x32\x15.Proto.CoordinateType\x12(\n\tlongitude\x18\x02 \x01(\x0b\x32\x15.Proto.CoordinateType\x12-\n\x10\x61ntenna_altitude\x18\x03 \x01(\x0b\x32\x13.Proto.AltitudeType\x12,\n\x0fgeo_id_altitude\x18\x04 \x01(\x0b\x32\x13.Proto.AltitudeType\x12+\n\x0etotal_altitude\x18\x05 \x01(\x0b\x32\x13.Proto.AltitudeType\x12\x0c\n\x04time\x18\x06 \x01(\r\"2\n\x0e\x43oordinateType\x12\x0f\n\x07\x64\x65grees\x18\x01 \x01(\x05\x12\x0f\n\x07minutes\x18\x02 \x01(\x05\".\n\x0c\x41ltitudeType\x12\x10\n\x08\x61ltitude\x18\x01 \x01(\x05\x12\x0c\n\x04unit\x18\x02 \x01(\x05\"7\n\x04\x42\x61ro\x12\x15\n\rbaro_pressure\x18\x01 \x01(\x05\x12\x18\n\x10\x62\x61ro_temperature\x18\x02 \x01(\x05\"\x95\x01\n\x03Imu\x12\x0f\n\x07\x61\x63\x63\x65l_x\x18\x01 \x01(\x05\x12\x0f\n\x07\x61\x63\x63\x65l_y\x18\x02 \x01(\x05\x12\x0f\n\x07\x61\x63\x63\x65l_z\x18\x03 \x01(\x05\x12\x0e\n\x06gyro_x\x18\x04 \x01(\x05\x12\x0e\n\x06gyro_y\x18\x05 \x01(\x05\x12\x0e\n\x06gyro_z\x18\x06 \x01(\x05\x12\r\n\x05mag_x\x18\x07 \x01(\x05\x12\r\n\x05mag_y\x18\x08 \x01(\x05\x12\r\n\x05mag_z\x18\t \x01(\x05\"\x80\x01\n\x07\x42\x61ttery\x12\x30\n\x0cpower_source\x18\x01 \x01(\x0e\x32\x1a.Proto.Battery.PowerSource\x12\x0f\n\x07voltage\x18\x02 \x01(\x05\"2\n\x0bPowerSource\x12\x0b\n\x07INVALID\x10\x00\x12\n\n\x06GROUND\x10\x01\x12\n\n\x06ROCKET\x10\x02\"5\n\x05\x46lash\x12\x16\n\x0esector_address\x18\x01 \x01(\r\x12\x14\n\x0clogging_rate\x18\x02 \x01(\r\"(\n\x0b\x44mbPressure\x12\x19\n\x11upper_pv_pressure\x18\x01 \x01(\x05\"=\n\x0bPbbPressure\x12\x13\n\x0bib_pressure\x18\x01 \x01(\x05\x12\x19\n\x11lower_pv_pressure\x18\x02 \x01(\x05\"@\n\x0ePbbTemperature\x12\x16\n\x0eib_temperature\x18\x01 \x01(\x05\x12\x16\n\x0epv_temperature\x18\x02 \x01(\x05\"R\n\x17\x43ombustionControlStatus\x12\x11\n\tvent_open\x18\x01 \x01(\x08\x12\x12\n\ndrain_open\x18\x02 \x01(\x08\x12\x10\n\x08mev_open\x18\x03 \x01(\x08\"e\n\x0bRcuPressure\x12\x14\n\x0cpt1_pressure\x18\x01 \x01(\x05\x12\x14\n\x0cpt2_pressure\x18\x02 \x01(\x05\x12\x14\n\x0cpt3_pressure\x18\x03 \x01(\x05\x12\x14\n\x0cpt4_pressure\x18\x04 \x01(\x05\"B\n\x0eRcuTemperature\x12\x17\n\x0ftc1_temperature\x18\x01 \x01(\x05\x12\x17\n\x0ftc2_temperature\x18\x02 \x01(\x05\"3\n\x0bNosLoadCell\x12\x11\n\tnos1_mass\x18\x01 \x01(\x05\x12\x11\n\tnos2_mass\x18\x02 \x01(\x05\"\xde\x01\n\x0bRelayStatus\x12\x10\n\x08\x61\x63\x31_open\x18\x01 \x01(\x08\x12\x10\n\x08\x61\x63\x32_open\x18\x02 \x01(\x08\x12\x11\n\tpbv1_open\x18\x03 \x01(\x08\x12\x11\n\tpbv2_open\x18\x04 \x01(\x08\x12\x11\n\tpbv3_open\x18\x05 \x01(\x08\x12\x11\n\tpbv4_open\x18\x06 \x01(\x08\x12\x11\n\tsol5_open\x18\n \x01(\x08\x12\x11\n\tsol6_open\x18\x0b \x01(\x08\x12\x11\n\tsol7_open\x18\x0c \x01(\x08\x12\x12\n\nsol8a_open\x18\r \x01(\x08\x12\x12\n\nsol8b_open\x18\x0e \x01(\x08\"\\\n\x0cPadBoxStatus\x12\x14\n\x0c\x63ontinuity_1\x18\x01 \x01(\x08\x12\x14\n\x0c\x63ontinuity_2\x18\x02 \x01(\x08\x12\x0f\n\x07\x62ox1_on\x18\x03 \x01(\x08\x12\x0f\n\x07\x62ox2_on\x18\x04 \x01(\x08\")\n\x12LaunchRailLoadCell\x12\x13\n\x0brocket_mass\x18\x01 \x01(\x05\"B\n\x0eSobTemperature\x12\x17\n\x0ftc1_temperature\x18\x01 \x01(\x05\x12\x17\n\x0ftc2_temperature\x18\x02 \x01(\x05\"E\n\x0bPressureLog\x12\x0c\n\x04time\x18\x01 \x01(\r\x12\x13\n\x0bpv_pressure\x18\x02 \x01(\x05\x12\x13\n\x0bib_pressure\x18\x03 \x01(\x05\x62\x06proto3') + +_globals = globals() +_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) +_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'TelemetryMessage_pb2', _globals) +if _descriptor._USE_C_DESCRIPTORS == False: + DESCRIPTOR._options = None + _globals['_TELEMETRYMESSAGE']._serialized_start=51 + _globals['_TELEMETRYMESSAGE']._serialized_end=866 + _globals['_GPS']._serialized_start=869 + _globals['_GPS']._serialized_end=1109 + _globals['_COORDINATETYPE']._serialized_start=1111 + _globals['_COORDINATETYPE']._serialized_end=1161 + _globals['_ALTITUDETYPE']._serialized_start=1163 + _globals['_ALTITUDETYPE']._serialized_end=1209 + _globals['_BARO']._serialized_start=1211 + _globals['_BARO']._serialized_end=1266 + _globals['_IMU']._serialized_start=1269 + _globals['_IMU']._serialized_end=1418 + _globals['_BATTERY']._serialized_start=1421 + _globals['_BATTERY']._serialized_end=1549 + _globals['_BATTERY_POWERSOURCE']._serialized_start=1499 + _globals['_BATTERY_POWERSOURCE']._serialized_end=1549 + _globals['_FLASH']._serialized_start=1551 + _globals['_FLASH']._serialized_end=1604 + _globals['_DMBPRESSURE']._serialized_start=1606 + _globals['_DMBPRESSURE']._serialized_end=1646 + _globals['_PBBPRESSURE']._serialized_start=1648 + _globals['_PBBPRESSURE']._serialized_end=1709 + _globals['_PBBTEMPERATURE']._serialized_start=1711 + _globals['_PBBTEMPERATURE']._serialized_end=1775 + _globals['_COMBUSTIONCONTROLSTATUS']._serialized_start=1777 + _globals['_COMBUSTIONCONTROLSTATUS']._serialized_end=1859 + _globals['_RCUPRESSURE']._serialized_start=1861 + _globals['_RCUPRESSURE']._serialized_end=1962 + _globals['_RCUTEMPERATURE']._serialized_start=1964 + _globals['_RCUTEMPERATURE']._serialized_end=2030 + _globals['_NOSLOADCELL']._serialized_start=2032 + _globals['_NOSLOADCELL']._serialized_end=2083 + _globals['_RELAYSTATUS']._serialized_start=2086 + _globals['_RELAYSTATUS']._serialized_end=2308 + _globals['_PADBOXSTATUS']._serialized_start=2310 + _globals['_PADBOXSTATUS']._serialized_end=2402 + _globals['_LAUNCHRAILLOADCELL']._serialized_start=2404 + _globals['_LAUNCHRAILLOADCELL']._serialized_end=2445 + _globals['_SOBTEMPERATURE']._serialized_start=2447 + _globals['_SOBTEMPERATURE']._serialized_end=2513 + _globals['_PRESSURELOG']._serialized_start=2515 + _globals['_PRESSURELOG']._serialized_end=2584 +# @@protoc_insertion_point(module_scope) diff --git a/SoarProto/_Python/TelemetryMessage_pb2.pyi b/SoarProto/_Python/TelemetryMessage_pb2.pyi new file mode 100644 index 0000000..eafdfe3 --- /dev/null +++ b/SoarProto/_Python/TelemetryMessage_pb2.pyi @@ -0,0 +1,257 @@ +import CoreProto_pb2 as _CoreProto_pb2 +from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union + +DESCRIPTOR: _descriptor.FileDescriptor + +class TelemetryMessage(_message.Message): + __slots__ = ("source", "target", "gps", "baro", "imu", "battery", "flashState", "dmbPressure", "pbbPressure", "pbbTemperature", "combustionControlStatus", "rcuPressure", "rcuTemperature", "nosLoadCell", "relayStatus", "padBoxStatus", "launchRailLoadCell", "sobTemperature", "pressureLog") + SOURCE_FIELD_NUMBER: _ClassVar[int] + TARGET_FIELD_NUMBER: _ClassVar[int] + GPS_FIELD_NUMBER: _ClassVar[int] + BARO_FIELD_NUMBER: _ClassVar[int] + IMU_FIELD_NUMBER: _ClassVar[int] + BATTERY_FIELD_NUMBER: _ClassVar[int] + FLASHSTATE_FIELD_NUMBER: _ClassVar[int] + DMBPRESSURE_FIELD_NUMBER: _ClassVar[int] + PBBPRESSURE_FIELD_NUMBER: _ClassVar[int] + PBBTEMPERATURE_FIELD_NUMBER: _ClassVar[int] + COMBUSTIONCONTROLSTATUS_FIELD_NUMBER: _ClassVar[int] + RCUPRESSURE_FIELD_NUMBER: _ClassVar[int] + RCUTEMPERATURE_FIELD_NUMBER: _ClassVar[int] + NOSLOADCELL_FIELD_NUMBER: _ClassVar[int] + RELAYSTATUS_FIELD_NUMBER: _ClassVar[int] + PADBOXSTATUS_FIELD_NUMBER: _ClassVar[int] + LAUNCHRAILLOADCELL_FIELD_NUMBER: _ClassVar[int] + SOBTEMPERATURE_FIELD_NUMBER: _ClassVar[int] + PRESSURELOG_FIELD_NUMBER: _ClassVar[int] + source: _CoreProto_pb2.Node + target: _CoreProto_pb2.Node + gps: Gps + baro: Baro + imu: Imu + battery: Battery + flashState: Flash + dmbPressure: DmbPressure + pbbPressure: PbbPressure + pbbTemperature: PbbTemperature + combustionControlStatus: CombustionControlStatus + rcuPressure: RcuPressure + rcuTemperature: RcuTemperature + nosLoadCell: NosLoadCell + relayStatus: RelayStatus + padBoxStatus: PadBoxStatus + launchRailLoadCell: LaunchRailLoadCell + sobTemperature: SobTemperature + pressureLog: PressureLog + def __init__(self, source: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., target: _Optional[_Union[_CoreProto_pb2.Node, str]] = ..., gps: _Optional[_Union[Gps, _Mapping]] = ..., baro: _Optional[_Union[Baro, _Mapping]] = ..., imu: _Optional[_Union[Imu, _Mapping]] = ..., battery: _Optional[_Union[Battery, _Mapping]] = ..., flashState: _Optional[_Union[Flash, _Mapping]] = ..., dmbPressure: _Optional[_Union[DmbPressure, _Mapping]] = ..., pbbPressure: _Optional[_Union[PbbPressure, _Mapping]] = ..., pbbTemperature: _Optional[_Union[PbbTemperature, _Mapping]] = ..., combustionControlStatus: _Optional[_Union[CombustionControlStatus, _Mapping]] = ..., rcuPressure: _Optional[_Union[RcuPressure, _Mapping]] = ..., rcuTemperature: _Optional[_Union[RcuTemperature, _Mapping]] = ..., nosLoadCell: _Optional[_Union[NosLoadCell, _Mapping]] = ..., relayStatus: _Optional[_Union[RelayStatus, _Mapping]] = ..., padBoxStatus: _Optional[_Union[PadBoxStatus, _Mapping]] = ..., launchRailLoadCell: _Optional[_Union[LaunchRailLoadCell, _Mapping]] = ..., sobTemperature: _Optional[_Union[SobTemperature, _Mapping]] = ..., pressureLog: _Optional[_Union[PressureLog, _Mapping]] = ...) -> None: ... + +class Gps(_message.Message): + __slots__ = ("latitude", "longitude", "antenna_altitude", "geo_id_altitude", "total_altitude", "time") + LATITUDE_FIELD_NUMBER: _ClassVar[int] + LONGITUDE_FIELD_NUMBER: _ClassVar[int] + ANTENNA_ALTITUDE_FIELD_NUMBER: _ClassVar[int] + GEO_ID_ALTITUDE_FIELD_NUMBER: _ClassVar[int] + TOTAL_ALTITUDE_FIELD_NUMBER: _ClassVar[int] + TIME_FIELD_NUMBER: _ClassVar[int] + latitude: CoordinateType + longitude: CoordinateType + antenna_altitude: AltitudeType + geo_id_altitude: AltitudeType + total_altitude: AltitudeType + time: int + def __init__(self, latitude: _Optional[_Union[CoordinateType, _Mapping]] = ..., longitude: _Optional[_Union[CoordinateType, _Mapping]] = ..., antenna_altitude: _Optional[_Union[AltitudeType, _Mapping]] = ..., geo_id_altitude: _Optional[_Union[AltitudeType, _Mapping]] = ..., total_altitude: _Optional[_Union[AltitudeType, _Mapping]] = ..., time: _Optional[int] = ...) -> None: ... + +class CoordinateType(_message.Message): + __slots__ = ("degrees", "minutes") + DEGREES_FIELD_NUMBER: _ClassVar[int] + MINUTES_FIELD_NUMBER: _ClassVar[int] + degrees: int + minutes: int + def __init__(self, degrees: _Optional[int] = ..., minutes: _Optional[int] = ...) -> None: ... + +class AltitudeType(_message.Message): + __slots__ = ("altitude", "unit") + ALTITUDE_FIELD_NUMBER: _ClassVar[int] + UNIT_FIELD_NUMBER: _ClassVar[int] + altitude: int + unit: int + def __init__(self, altitude: _Optional[int] = ..., unit: _Optional[int] = ...) -> None: ... + +class Baro(_message.Message): + __slots__ = ("baro_pressure", "baro_temperature") + BARO_PRESSURE_FIELD_NUMBER: _ClassVar[int] + BARO_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + baro_pressure: int + baro_temperature: int + def __init__(self, baro_pressure: _Optional[int] = ..., baro_temperature: _Optional[int] = ...) -> None: ... + +class Imu(_message.Message): + __slots__ = ("accel_x", "accel_y", "accel_z", "gyro_x", "gyro_y", "gyro_z", "mag_x", "mag_y", "mag_z") + ACCEL_X_FIELD_NUMBER: _ClassVar[int] + ACCEL_Y_FIELD_NUMBER: _ClassVar[int] + ACCEL_Z_FIELD_NUMBER: _ClassVar[int] + GYRO_X_FIELD_NUMBER: _ClassVar[int] + GYRO_Y_FIELD_NUMBER: _ClassVar[int] + GYRO_Z_FIELD_NUMBER: _ClassVar[int] + MAG_X_FIELD_NUMBER: _ClassVar[int] + MAG_Y_FIELD_NUMBER: _ClassVar[int] + MAG_Z_FIELD_NUMBER: _ClassVar[int] + accel_x: int + accel_y: int + accel_z: int + gyro_x: int + gyro_y: int + gyro_z: int + mag_x: int + mag_y: int + mag_z: int + def __init__(self, accel_x: _Optional[int] = ..., accel_y: _Optional[int] = ..., accel_z: _Optional[int] = ..., gyro_x: _Optional[int] = ..., gyro_y: _Optional[int] = ..., gyro_z: _Optional[int] = ..., mag_x: _Optional[int] = ..., mag_y: _Optional[int] = ..., mag_z: _Optional[int] = ...) -> None: ... + +class Battery(_message.Message): + __slots__ = ("power_source", "voltage") + class PowerSource(int, metaclass=_enum_type_wrapper.EnumTypeWrapper): + __slots__ = () + INVALID: _ClassVar[Battery.PowerSource] + GROUND: _ClassVar[Battery.PowerSource] + ROCKET: _ClassVar[Battery.PowerSource] + INVALID: Battery.PowerSource + GROUND: Battery.PowerSource + ROCKET: Battery.PowerSource + POWER_SOURCE_FIELD_NUMBER: _ClassVar[int] + VOLTAGE_FIELD_NUMBER: _ClassVar[int] + power_source: Battery.PowerSource + voltage: int + def __init__(self, power_source: _Optional[_Union[Battery.PowerSource, str]] = ..., voltage: _Optional[int] = ...) -> None: ... + +class Flash(_message.Message): + __slots__ = ("sector_address", "logging_rate") + SECTOR_ADDRESS_FIELD_NUMBER: _ClassVar[int] + LOGGING_RATE_FIELD_NUMBER: _ClassVar[int] + sector_address: int + logging_rate: int + def __init__(self, sector_address: _Optional[int] = ..., logging_rate: _Optional[int] = ...) -> None: ... + +class DmbPressure(_message.Message): + __slots__ = ("upper_pv_pressure",) + UPPER_PV_PRESSURE_FIELD_NUMBER: _ClassVar[int] + upper_pv_pressure: int + def __init__(self, upper_pv_pressure: _Optional[int] = ...) -> None: ... + +class PbbPressure(_message.Message): + __slots__ = ("ib_pressure", "lower_pv_pressure") + IB_PRESSURE_FIELD_NUMBER: _ClassVar[int] + LOWER_PV_PRESSURE_FIELD_NUMBER: _ClassVar[int] + ib_pressure: int + lower_pv_pressure: int + def __init__(self, ib_pressure: _Optional[int] = ..., lower_pv_pressure: _Optional[int] = ...) -> None: ... + +class PbbTemperature(_message.Message): + __slots__ = ("ib_temperature", "pv_temperature") + IB_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + PV_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + ib_temperature: int + pv_temperature: int + def __init__(self, ib_temperature: _Optional[int] = ..., pv_temperature: _Optional[int] = ...) -> None: ... + +class CombustionControlStatus(_message.Message): + __slots__ = ("vent_open", "drain_open", "mev_open") + VENT_OPEN_FIELD_NUMBER: _ClassVar[int] + DRAIN_OPEN_FIELD_NUMBER: _ClassVar[int] + MEV_OPEN_FIELD_NUMBER: _ClassVar[int] + vent_open: bool + drain_open: bool + mev_open: bool + def __init__(self, vent_open: bool = ..., drain_open: bool = ..., mev_open: bool = ...) -> None: ... + +class RcuPressure(_message.Message): + __slots__ = ("pt1_pressure", "pt2_pressure", "pt3_pressure", "pt4_pressure") + PT1_PRESSURE_FIELD_NUMBER: _ClassVar[int] + PT2_PRESSURE_FIELD_NUMBER: _ClassVar[int] + PT3_PRESSURE_FIELD_NUMBER: _ClassVar[int] + PT4_PRESSURE_FIELD_NUMBER: _ClassVar[int] + pt1_pressure: int + pt2_pressure: int + pt3_pressure: int + pt4_pressure: int + def __init__(self, pt1_pressure: _Optional[int] = ..., pt2_pressure: _Optional[int] = ..., pt3_pressure: _Optional[int] = ..., pt4_pressure: _Optional[int] = ...) -> None: ... + +class RcuTemperature(_message.Message): + __slots__ = ("tc1_temperature", "tc2_temperature") + TC1_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + TC2_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + tc1_temperature: int + tc2_temperature: int + def __init__(self, tc1_temperature: _Optional[int] = ..., tc2_temperature: _Optional[int] = ...) -> None: ... + +class NosLoadCell(_message.Message): + __slots__ = ("nos1_mass", "nos2_mass") + NOS1_MASS_FIELD_NUMBER: _ClassVar[int] + NOS2_MASS_FIELD_NUMBER: _ClassVar[int] + nos1_mass: int + nos2_mass: int + def __init__(self, nos1_mass: _Optional[int] = ..., nos2_mass: _Optional[int] = ...) -> None: ... + +class RelayStatus(_message.Message): + __slots__ = ("ac1_open", "ac2_open", "pbv1_open", "pbv2_open", "pbv3_open", "pbv4_open", "sol5_open", "sol6_open", "sol7_open", "sol8a_open", "sol8b_open") + AC1_OPEN_FIELD_NUMBER: _ClassVar[int] + AC2_OPEN_FIELD_NUMBER: _ClassVar[int] + PBV1_OPEN_FIELD_NUMBER: _ClassVar[int] + PBV2_OPEN_FIELD_NUMBER: _ClassVar[int] + PBV3_OPEN_FIELD_NUMBER: _ClassVar[int] + PBV4_OPEN_FIELD_NUMBER: _ClassVar[int] + SOL5_OPEN_FIELD_NUMBER: _ClassVar[int] + SOL6_OPEN_FIELD_NUMBER: _ClassVar[int] + SOL7_OPEN_FIELD_NUMBER: _ClassVar[int] + SOL8A_OPEN_FIELD_NUMBER: _ClassVar[int] + SOL8B_OPEN_FIELD_NUMBER: _ClassVar[int] + ac1_open: bool + ac2_open: bool + pbv1_open: bool + pbv2_open: bool + pbv3_open: bool + pbv4_open: bool + sol5_open: bool + sol6_open: bool + sol7_open: bool + sol8a_open: bool + sol8b_open: bool + def __init__(self, ac1_open: bool = ..., ac2_open: bool = ..., pbv1_open: bool = ..., pbv2_open: bool = ..., pbv3_open: bool = ..., pbv4_open: bool = ..., sol5_open: bool = ..., sol6_open: bool = ..., sol7_open: bool = ..., sol8a_open: bool = ..., sol8b_open: bool = ...) -> None: ... + +class PadBoxStatus(_message.Message): + __slots__ = ("continuity_1", "continuity_2", "box1_on", "box2_on") + CONTINUITY_1_FIELD_NUMBER: _ClassVar[int] + CONTINUITY_2_FIELD_NUMBER: _ClassVar[int] + BOX1_ON_FIELD_NUMBER: _ClassVar[int] + BOX2_ON_FIELD_NUMBER: _ClassVar[int] + continuity_1: bool + continuity_2: bool + box1_on: bool + box2_on: bool + def __init__(self, continuity_1: bool = ..., continuity_2: bool = ..., box1_on: bool = ..., box2_on: bool = ...) -> None: ... + +class LaunchRailLoadCell(_message.Message): + __slots__ = ("rocket_mass",) + ROCKET_MASS_FIELD_NUMBER: _ClassVar[int] + rocket_mass: int + def __init__(self, rocket_mass: _Optional[int] = ...) -> None: ... + +class SobTemperature(_message.Message): + __slots__ = ("tc1_temperature", "tc2_temperature") + TC1_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + TC2_TEMPERATURE_FIELD_NUMBER: _ClassVar[int] + tc1_temperature: int + tc2_temperature: int + def __init__(self, tc1_temperature: _Optional[int] = ..., tc2_temperature: _Optional[int] = ...) -> None: ... + +class PressureLog(_message.Message): + __slots__ = ("time", "pv_pressure", "ib_pressure") + TIME_FIELD_NUMBER: _ClassVar[int] + PV_PRESSURE_FIELD_NUMBER: _ClassVar[int] + IB_PRESSURE_FIELD_NUMBER: _ClassVar[int] + time: int + pv_pressure: int + ib_pressure: int + def __init__(self, time: _Optional[int] = ..., pv_pressure: _Optional[int] = ..., ib_pressure: _Optional[int] = ...) -> None: ...