Change protocol hardware address to a table and handle different address types

protocol/cpp/include/solarxr_protocol/generated/all_generated.h

@@ -30,6 +30,8 @@ struct LogDataBuilder;
 
 struct Temperature;
 
+struct Ipv4Address;
+
 namespace hardware_info {
 
 struct HardwareAddress;
@@ -1114,6 +1116,25 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Temperature FLATBUFFERS_FINAL_CLASS {
 };
 FLATBUFFERS_STRUCT_END(Temperature, 4);
 
+/// The 4 bytes of an ip address are stored in 32 bits in big endian order.
+/// We will switch over to fixed size arrays when they are supported better.
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ipv4Address FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint32_t addr_;
+
+ public:
+  Ipv4Address()
+      : addr_(0) {
+  }
+  Ipv4Address(uint32_t _addr)
+      : addr_(flatbuffers::EndianScalar(_addr)) {
+  }
+  uint32_t addr() const {
+    return flatbuffers::EndianScalar(addr_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Ipv4Address, 4);
+
 namespace hardware_info {
 
 /// A MAC address or a bluetooth address, or some other uniquely identifying address
@@ -1338,7 +1359,8 @@ struct HardwareInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_MANUFACTURER = 10,
     VT_HARDWARE_REVISION = 12,
     VT_FIRMWARE_VERSION = 14,
-    VT_HARDWARE_ADDRESS = 16
+    VT_HARDWARE_ADDRESS = 16,
+    VT_IP_ADDRESS = 18
   };
   solarxr_protocol::datatypes::hardware_info::McuType mcu_id() const {
     return static_cast<solarxr_protocol::datatypes::hardware_info::McuType>(GetField<uint16_t>(VT_MCU_ID, 0));
@@ -1366,6 +1388,9 @@ struct HardwareInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address() const {
     return GetStruct<const solarxr_protocol::datatypes::hardware_info::HardwareAddress *>(VT_HARDWARE_ADDRESS);
   }
+  const solarxr_protocol::datatypes::Ipv4Address *ip_address() const {
+    return GetStruct<const solarxr_protocol::datatypes::Ipv4Address *>(VT_IP_ADDRESS);
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint16_t>(verifier, VT_MCU_ID, 2) &&
@@ -1380,6 +1405,7 @@ struct HardwareInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyOffset(verifier, VT_FIRMWARE_VERSION) &&
            verifier.VerifyString(firmware_version()) &&
            VerifyField<solarxr_protocol::datatypes::hardware_info::HardwareAddress>(verifier, VT_HARDWARE_ADDRESS, 8) &&
+           VerifyField<solarxr_protocol::datatypes::Ipv4Address>(verifier, VT_IP_ADDRESS, 4) &&
            verifier.EndTable();
   }
 };
@@ -1409,6 +1435,9 @@ struct HardwareInfoBuilder {
   void add_hardware_address(const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address) {
     fbb_.AddStruct(HardwareInfo::VT_HARDWARE_ADDRESS, hardware_address);
   }
+  void add_ip_address(const solarxr_protocol::datatypes::Ipv4Address *ip_address) {
+    fbb_.AddStruct(HardwareInfo::VT_IP_ADDRESS, ip_address);
+  }
   explicit HardwareInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -1428,8 +1457,10 @@ inline flatbuffers::Offset<HardwareInfo> CreateHardwareInfo(
     flatbuffers::Offset<flatbuffers::String> manufacturer = 0,
     flatbuffers::Offset<flatbuffers::String> hardware_revision = 0,
     flatbuffers::Offset<flatbuffers::String> firmware_version = 0,
-    const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address = nullptr) {
+    const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address = nullptr,
+    const solarxr_protocol::datatypes::Ipv4Address *ip_address = nullptr) {
   HardwareInfoBuilder builder_(_fbb);
+  builder_.add_ip_address(ip_address);
   builder_.add_hardware_address(hardware_address);
   builder_.add_firmware_version(firmware_version);
   builder_.add_hardware_revision(hardware_revision);
@@ -1448,7 +1479,8 @@ inline flatbuffers::Offset<HardwareInfo> CreateHardwareInfoDirect(
     const char *manufacturer = nullptr,
     const char *hardware_revision = nullptr,
     const char *firmware_version = nullptr,
-    const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address = nullptr) {
+    const solarxr_protocol::datatypes::hardware_info::HardwareAddress *hardware_address = nullptr,
+    const solarxr_protocol::datatypes::Ipv4Address *ip_address = nullptr) {
   auto display_name__ = display_name ? _fbb.CreateString(display_name) : 0;
   auto model__ = model ? _fbb.CreateString(model) : 0;
   auto manufacturer__ = manufacturer ? _fbb.CreateString(manufacturer) : 0;
@@ -1462,7 +1494,8 @@ inline flatbuffers::Offset<HardwareInfo> CreateHardwareInfoDirect(
       manufacturer__,
       hardware_revision__,
       firmware_version__,
-      hardware_address);
+      hardware_address,
+      ip_address);
 }
 
 /// Mostly-dynamic status info about a tracked device's firmware

protocol/java/src/solarxr_protocol/datatypes/Ipv4Address.java

@@ -0,0 +1,49 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+/**
+ * The 4 bytes of an ip address are stored in 32 bits in big endian order.
+ * We will switch over to fixed size arrays when they are supported better.
+ */
+@SuppressWarnings("unused")
+public final class Ipv4Address extends Struct {
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Ipv4Address __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long addr() { return (long)bb.getInt(bb_pos + 0) & 0xFFFFFFFFL; }
+
+  public static int createIpv4Address(FlatBufferBuilder builder, long addr) {
+    builder.prep(4, 4);
+    builder.putInt((int) addr);
+    return builder.offset();
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Ipv4Address get(int j) { return get(new Ipv4Address(), j); }
+    public Ipv4Address get(Ipv4Address obj, int j) {  return obj.__assign(__element(j), bb); }
+  }
+  public Ipv4AddressT unpack() {
+    Ipv4AddressT _o = new Ipv4AddressT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(Ipv4AddressT _o) {
+    long _oAddr = addr();
+    _o.setAddr(_oAddr);
+  }
+  public static int pack(FlatBufferBuilder builder, Ipv4AddressT _o) {
+    if (_o == null) return 0;
+    return createIpv4Address(
+      builder,
+      _o.getAddr());
+  }
+}
+

protocol/java/src/solarxr_protocol/datatypes/Ipv4AddressT.java

@@ -0,0 +1,22 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.datatypes;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class Ipv4AddressT {
+  private long addr;
+
+  public long getAddr() { return addr; }
+
+  public void setAddr(long addr) { this.addr = addr; }
+
+
+  public Ipv4AddressT() {
+    this.addr = 0L;
+  }
+}
+

protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareInfo.java

@@ -51,15 +51,18 @@ public final class HardwareInfo extends Table {
   public ByteBuffer firmwareVersionInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 14, 1); }
   public solarxr_protocol.datatypes.hardware_info.HardwareAddress hardwareAddress() { return hardwareAddress(new solarxr_protocol.datatypes.hardware_info.HardwareAddress()); }
   public solarxr_protocol.datatypes.hardware_info.HardwareAddress hardwareAddress(solarxr_protocol.datatypes.hardware_info.HardwareAddress obj) { int o = __offset(16); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
+  public solarxr_protocol.datatypes.Ipv4Address ipAddress() { return ipAddress(new solarxr_protocol.datatypes.Ipv4Address()); }
+  public solarxr_protocol.datatypes.Ipv4Address ipAddress(solarxr_protocol.datatypes.Ipv4Address obj) { int o = __offset(18); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
 
-  public static void startHardwareInfo(FlatBufferBuilder builder) { builder.startTable(7); }
+  public static void startHardwareInfo(FlatBufferBuilder builder) { builder.startTable(8); }
   public static void addMcuId(FlatBufferBuilder builder, int mcuId) { builder.addShort(0, (short) mcuId, (short) 0); }
   public static void addDisplayName(FlatBufferBuilder builder, int displayNameOffset) { builder.addOffset(1, displayNameOffset, 0); }
   public static void addModel(FlatBufferBuilder builder, int modelOffset) { builder.addOffset(2, modelOffset, 0); }
   public static void addManufacturer(FlatBufferBuilder builder, int manufacturerOffset) { builder.addOffset(3, manufacturerOffset, 0); }
   public static void addHardwareRevision(FlatBufferBuilder builder, int hardwareRevisionOffset) { builder.addOffset(4, hardwareRevisionOffset, 0); }
   public static void addFirmwareVersion(FlatBufferBuilder builder, int firmwareVersionOffset) { builder.addOffset(5, firmwareVersionOffset, 0); }
   public static void addHardwareAddress(FlatBufferBuilder builder, int hardwareAddressOffset) { builder.addStruct(6, hardwareAddressOffset, 0); }
+  public static void addIpAddress(FlatBufferBuilder builder, int ipAddressOffset) { builder.addStruct(7, ipAddressOffset, 0); }
   public static int endHardwareInfo(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
@@ -91,6 +94,8 @@ public void unpackTo(HardwareInfoT _o) {
     _o.setFirmwareVersion(_oFirmwareVersion);
     if (hardwareAddress() != null) hardwareAddress().unpackTo(_o.getHardwareAddress());
     else _o.setHardwareAddress(null);
+    if (ipAddress() != null) ipAddress().unpackTo(_o.getIpAddress());
+    else _o.setIpAddress(null);
   }
   public static int pack(FlatBufferBuilder builder, HardwareInfoT _o) {
     if (_o == null) return 0;
@@ -107,6 +112,7 @@ public static int pack(FlatBufferBuilder builder, HardwareInfoT _o) {
     addHardwareRevision(builder, _hardwareRevision);
     addFirmwareVersion(builder, _firmwareVersion);
     addHardwareAddress(builder, solarxr_protocol.datatypes.hardware_info.HardwareAddress.pack(builder, _o.getHardwareAddress()));
+    addIpAddress(builder, solarxr_protocol.datatypes.Ipv4Address.pack(builder, _o.getIpAddress()));
     return endHardwareInfo(builder);
   }
 }

protocol/java/src/solarxr_protocol/datatypes/hardware_info/HardwareInfoT.java

@@ -15,6 +15,7 @@ public class HardwareInfoT {
   private String hardwareRevision;
   private String firmwareVersion;
   private solarxr_protocol.datatypes.hardware_info.HardwareAddressT hardwareAddress;
+  private solarxr_protocol.datatypes.Ipv4AddressT ipAddress;
 
   public int getMcuId() { return mcuId; }
 
@@ -44,6 +45,10 @@ public class HardwareInfoT {
 
   public void setHardwareAddress(solarxr_protocol.datatypes.hardware_info.HardwareAddressT hardwareAddress) { this.hardwareAddress = hardwareAddress; }
 
+  public solarxr_protocol.datatypes.Ipv4AddressT getIpAddress() { return ipAddress; }
+
+  public void setIpAddress(solarxr_protocol.datatypes.Ipv4AddressT ipAddress) { this.ipAddress = ipAddress; }
+
 
   public HardwareInfoT() {
     this.mcuId = 0;
@@ -53,6 +58,7 @@ public HardwareInfoT() {
     this.hardwareRevision = null;
     this.firmwareVersion = null;
     this.hardwareAddress = new solarxr_protocol.datatypes.hardware_info.HardwareAddressT();
+    this.ipAddress = new solarxr_protocol.datatypes.Ipv4AddressT();
   }
 }
 

protocol/rust/src/generated/mod.rs

@@ -80,6 +80,8 @@ pub mod solarxr_protocol {
     pub use self::log_data_generated::*;
     mod temperature_generated;
     pub use self::temperature_generated::*;
+    mod ipv_4address_generated;
+    pub use self::ipv_4address_generated::*;
   } // datatypes
   pub mod rpc {
     use super::*;

protocol/rust/src/generated/solarxr_protocol/datatypes/hardware_info/hardware_info_generated.rs

@@ -32,6 +32,7 @@ impl<'a> HardwareInfo<'a> {
   pub const VT_HARDWARE_REVISION: flatbuffers::VOffsetT = 12;
   pub const VT_FIRMWARE_VERSION: flatbuffers::VOffsetT = 14;
   pub const VT_HARDWARE_ADDRESS: flatbuffers::VOffsetT = 16;
+  pub const VT_IP_ADDRESS: flatbuffers::VOffsetT = 18;
 
   #[inline]
   pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
@@ -43,6 +44,7 @@ impl<'a> HardwareInfo<'a> {
     args: &'args HardwareInfoArgs<'args>
   ) -> flatbuffers::WIPOffset<HardwareInfo<'bldr>> {
     let mut builder = HardwareInfoBuilder::new(_fbb);
+    if let Some(x) = args.ip_address { builder.add_ip_address(x); }
     if let Some(x) = args.hardware_address { builder.add_hardware_address(x); }
     if let Some(x) = args.firmware_version { builder.add_firmware_version(x); }
     if let Some(x) = args.hardware_revision { builder.add_hardware_revision(x); }
@@ -87,6 +89,10 @@ impl<'a> HardwareInfo<'a> {
   pub fn hardware_address(&self) -> Option<&'a HardwareAddress> {
     self._tab.get::<HardwareAddress>(HardwareInfo::VT_HARDWARE_ADDRESS, None)
   }
+  #[inline]
+  pub fn ip_address(&self) -> Option<&'a super::Ipv4Address> {
+    self._tab.get::<super::Ipv4Address>(HardwareInfo::VT_IP_ADDRESS, None)
+  }
 }
 
 impl flatbuffers::Verifiable for HardwareInfo<'_> {
@@ -103,6 +109,7 @@ impl flatbuffers::Verifiable for HardwareInfo<'_> {
      .visit_field::<flatbuffers::ForwardsUOffset<&str>>("hardware_revision", Self::VT_HARDWARE_REVISION, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<&str>>("firmware_version", Self::VT_FIRMWARE_VERSION, false)?
      .visit_field::<HardwareAddress>("hardware_address", Self::VT_HARDWARE_ADDRESS, false)?
+     .visit_field::<super::Ipv4Address>("ip_address", Self::VT_IP_ADDRESS, false)?
      .finish();
     Ok(())
   }
@@ -115,6 +122,7 @@ pub struct HardwareInfoArgs<'a> {
     pub hardware_revision: Option<flatbuffers::WIPOffset<&'a str>>,
     pub firmware_version: Option<flatbuffers::WIPOffset<&'a str>>,
     pub hardware_address: Option<&'a HardwareAddress>,
+    pub ip_address: Option<&'a super::Ipv4Address>,
 }
 impl<'a> Default for HardwareInfoArgs<'a> {
   #[inline]
@@ -127,6 +135,7 @@ impl<'a> Default for HardwareInfoArgs<'a> {
       hardware_revision: None,
       firmware_version: None,
       hardware_address: None,
+      ip_address: None,
     }
   }
 }
@@ -165,6 +174,10 @@ impl<'a: 'b, 'b> HardwareInfoBuilder<'a, 'b> {
     self.fbb_.push_slot_always::<&HardwareAddress>(HardwareInfo::VT_HARDWARE_ADDRESS, hardware_address);
   }
   #[inline]
+  pub fn add_ip_address(&mut self, ip_address: &super::Ipv4Address) {
+    self.fbb_.push_slot_always::<&super::Ipv4Address>(HardwareInfo::VT_IP_ADDRESS, ip_address);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HardwareInfoBuilder<'a, 'b> {
     let start = _fbb.start_table();
     HardwareInfoBuilder {
@@ -189,6 +202,7 @@ impl core::fmt::Debug for HardwareInfo<'_> {
       ds.field("hardware_revision", &self.hardware_revision());
       ds.field("firmware_version", &self.firmware_version());
       ds.field("hardware_address", &self.hardware_address());
+      ds.field("ip_address", &self.ip_address());
       ds.finish()
   }
 }