Add StatusPublicNetwork

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

@@ -333,6 +333,9 @@ struct StatusSystemUpdateBuilder;
 struct StatusSystemFixed;
 struct StatusSystemFixedBuilder;
 
+struct StatusPublicNetwork;
+struct StatusPublicNetworkBuilder;
+
 struct StatusMessage;
 struct StatusMessageBuilder;
 
@@ -1997,35 +2000,38 @@ enum class StatusData : uint8_t {
   StatusTrackerError = 2,
   StatusSteamVRDisconnected = 3,
   StatusUnassignedHMD = 4,
+  StatusPublicNetwork = 5,
   MIN = NONE,
-  MAX = StatusUnassignedHMD
+  MAX = StatusPublicNetwork
 };
 
-inline const StatusData (&EnumValuesStatusData())[5] {
+inline const StatusData (&EnumValuesStatusData())[6] {
   static const StatusData values[] = {
     StatusData::NONE,
     StatusData::StatusTrackerReset,
     StatusData::StatusTrackerError,
     StatusData::StatusSteamVRDisconnected,
-    StatusData::StatusUnassignedHMD
+    StatusData::StatusUnassignedHMD,
+    StatusData::StatusPublicNetwork
   };
   return values;
 }
 
 inline const char * const *EnumNamesStatusData() {
-  static const char * const names[6] = {
+  static const char * const names[7] = {
     "NONE",
     "StatusTrackerReset",
     "StatusTrackerError",
     "StatusSteamVRDisconnected",
     "StatusUnassignedHMD",
+    "StatusPublicNetwork",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameStatusData(StatusData e) {
-  if (flatbuffers::IsOutRange(e, StatusData::NONE, StatusData::StatusUnassignedHMD)) return "";
+  if (flatbuffers::IsOutRange(e, StatusData::NONE, StatusData::StatusPublicNetwork)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesStatusData()[index];
 }
@@ -2050,6 +2056,10 @@ template<> struct StatusDataTraits<solarxr_protocol::rpc::StatusUnassignedHMD> {
   static const StatusData enum_value = StatusData::StatusUnassignedHMD;
 };
 
+template<> struct StatusDataTraits<solarxr_protocol::rpc::StatusPublicNetwork> {
+  static const StatusData enum_value = StatusData::StatusPublicNetwork;
+};
+
 bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, StatusData type);
 bool VerifyStatusDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<StatusData> *types);
 
@@ -9488,6 +9498,36 @@ inline flatbuffers::Offset<StatusSystemFixed> CreateStatusSystemFixed(
   return builder_.Finish();
 }
 
+/// When the server detects a public network profile
+struct StatusPublicNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef StatusPublicNetworkBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct StatusPublicNetworkBuilder {
+  typedef StatusPublicNetwork Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit StatusPublicNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<StatusPublicNetwork> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<StatusPublicNetwork>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<StatusPublicNetwork> CreateStatusPublicNetwork(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  StatusPublicNetworkBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 /// An status is some kind of warning sent by the server, it's mainly made for
 /// showing problems with the server and need attention from the user.
 struct StatusMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -9525,6 +9565,9 @@ struct StatusMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const solarxr_protocol::rpc::StatusUnassignedHMD *data_as_StatusUnassignedHMD() const {
     return data_type() == solarxr_protocol::rpc::StatusData::StatusUnassignedHMD ? static_cast<const solarxr_protocol::rpc::StatusUnassignedHMD *>(data()) : nullptr;
   }
+  const solarxr_protocol::rpc::StatusPublicNetwork *data_as_StatusPublicNetwork() const {
+    return data_type() == solarxr_protocol::rpc::StatusData::StatusPublicNetwork ? static_cast<const solarxr_protocol::rpc::StatusPublicNetwork *>(data()) : nullptr;
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_ID, 4) &&
@@ -9552,6 +9595,10 @@ template<> inline const solarxr_protocol::rpc::StatusUnassignedHMD *StatusMessag
   return data_as_StatusUnassignedHMD();
 }
 
+template<> inline const solarxr_protocol::rpc::StatusPublicNetwork *StatusMessage::data_as<solarxr_protocol::rpc::StatusPublicNetwork>() const {
+  return data_as_StatusPublicNetwork();
+}
+
 struct StatusMessageBuilder {
   typedef StatusMessage Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -12202,6 +12249,10 @@ inline bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, S
       auto ptr = reinterpret_cast<const solarxr_protocol::rpc::StatusUnassignedHMD *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case StatusData::StatusPublicNetwork: {
+      auto ptr = reinterpret_cast<const solarxr_protocol::rpc::StatusPublicNetwork *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }

protocol/java/src/solarxr_protocol/rpc/StatusData.java

@@ -10,8 +10,9 @@ private StatusData() { }
   public static final byte StatusTrackerError = 2;
   public static final byte StatusSteamVRDisconnected = 3;
   public static final byte StatusUnassignedHMD = 4;
+  public static final byte StatusPublicNetwork = 5;
 
-  public static final String[] names = { "NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", };
+  public static final String[] names = { "NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork", };
 
   public static String name(int e) { return names[e]; }
 }

protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java

@@ -25,13 +25,15 @@ public StatusDataUnion() {
   public solarxr_protocol.rpc.StatusTrackerErrorT asStatusTrackerError() { return (solarxr_protocol.rpc.StatusTrackerErrorT) value; }
   public solarxr_protocol.rpc.StatusSteamVRDisconnectedT asStatusSteamVRDisconnected() { return (solarxr_protocol.rpc.StatusSteamVRDisconnectedT) value; }
   public solarxr_protocol.rpc.StatusUnassignedHMDT asStatusUnassignedHMD() { return (solarxr_protocol.rpc.StatusUnassignedHMDT) value; }
+  public solarxr_protocol.rpc.StatusPublicNetworkT asStatusPublicNetwork() { return (solarxr_protocol.rpc.StatusPublicNetworkT) value; }
 
   public static int pack(FlatBufferBuilder builder, StatusDataUnion _o) {
     switch (_o.type) {
       case StatusData.StatusTrackerReset: return solarxr_protocol.rpc.StatusTrackerReset.pack(builder, _o.asStatusTrackerReset());
       case StatusData.StatusTrackerError: return solarxr_protocol.rpc.StatusTrackerError.pack(builder, _o.asStatusTrackerError());
       case StatusData.StatusSteamVRDisconnected: return solarxr_protocol.rpc.StatusSteamVRDisconnected.pack(builder, _o.asStatusSteamVRDisconnected());
       case StatusData.StatusUnassignedHMD: return solarxr_protocol.rpc.StatusUnassignedHMD.pack(builder, _o.asStatusUnassignedHMD());
+      case StatusData.StatusPublicNetwork: return solarxr_protocol.rpc.StatusPublicNetwork.pack(builder, _o.asStatusPublicNetwork());
       default: return 0;
     }
   }

protocol/java/src/solarxr_protocol/rpc/StatusMessage.java

@@ -90,6 +90,10 @@ public void unpackTo(StatusMessageT _o) {
         _oDataValue = data(new solarxr_protocol.rpc.StatusUnassignedHMD());
         _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusUnassignedHMD) _oDataValue).unpack() : null);
         break;
+      case solarxr_protocol.rpc.StatusData.StatusPublicNetwork:
+        _oDataValue = data(new solarxr_protocol.rpc.StatusPublicNetwork());
+        _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusPublicNetwork) _oDataValue).unpack() : null);
+        break;
       default: break;
     }
     _o.setData(_oData);

protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java

@@ -0,0 +1,47 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+/**
+ * When the server detects a public network profile
+ */
+@SuppressWarnings("unused")
+public final class StatusPublicNetwork extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); }
+  public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb) { return getRootAsStatusPublicNetwork(_bb, new StatusPublicNetwork()); }
+  public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb, StatusPublicNetwork obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public StatusPublicNetwork __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startStatusPublicNetwork(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endStatusPublicNetwork(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  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 StatusPublicNetwork get(int j) { return get(new StatusPublicNetwork(), j); }
+    public StatusPublicNetwork get(StatusPublicNetwork obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+  public StatusPublicNetworkT unpack() {
+    StatusPublicNetworkT _o = new StatusPublicNetworkT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(StatusPublicNetworkT _o) {
+  }
+  public static int pack(FlatBufferBuilder builder, StatusPublicNetworkT _o) {
+    if (_o == null) return 0;
+    startStatusPublicNetwork(builder);
+    return endStatusPublicNetwork(builder);
+  }
+}
+

protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java

@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class StatusPublicNetworkT {
+
+
+  public StatusPublicNetworkT() {
+  }
+}
+

protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt

@@ -10,7 +10,8 @@ class StatusData private constructor() {
         const val StatusTrackerError: UByte = 2u
         const val StatusSteamVRDisconnected: UByte = 3u
         const val StatusUnassignedHMD: UByte = 4u
-        val names : Array<String> = arrayOf("NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD")
+        const val StatusPublicNetwork: UByte = 5u
+        val names : Array<String> = arrayOf("NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork")
         @JvmStatic
         fun name(e: Int) : String = names[e]
     }

protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt

@@ -0,0 +1,40 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc
+
+import java.nio.*
+import kotlin.math.sign
+import com.google.flatbuffers.*
+
+/**
+ * When the server detects a public network profile
+ */
+@Suppress("unused")
+class StatusPublicNetwork : Table() {
+
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
+    }
+    fun __assign(_i: Int, _bb: ByteBuffer) : StatusPublicNetwork {
+        __init(_i, _bb)
+        return this
+    }
+    companion object {
+        @JvmStatic
+        fun validateVersion() = Constants.FLATBUFFERS_22_10_26()
+        @JvmStatic
+        fun getRootAsStatusPublicNetwork(_bb: ByteBuffer): StatusPublicNetwork = getRootAsStatusPublicNetwork(_bb, StatusPublicNetwork())
+        @JvmStatic
+        fun getRootAsStatusPublicNetwork(_bb: ByteBuffer, obj: StatusPublicNetwork): StatusPublicNetwork {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        @JvmStatic
+        fun startStatusPublicNetwork(builder: FlatBufferBuilder) = builder.startTable(0)
+        @JvmStatic
+        fun endStatusPublicNetwork(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+    }
+}

protocol/rust/src/generated/mod.rs

@@ -302,6 +302,8 @@ pub mod solarxr_protocol {
     pub use self::status_system_update_generated::*;
     mod status_system_fixed_generated;
     pub use self::status_system_fixed_generated::*;
+    mod status_public_network_generated;
+    pub use self::status_public_network_generated::*;
     mod status_message_generated;
     pub use self::status_message_generated::*;
     mod set_pause_tracking_request_generated;

protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs

@@ -12,15 +12,16 @@ use super::*;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_STATUS_DATA: u8 = 0;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MAX_STATUS_DATA: u8 = 4;
+pub const ENUM_MAX_STATUS_DATA: u8 = 5;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
-pub const ENUM_VALUES_STATUS_DATA: [StatusData; 5] = [
+pub const ENUM_VALUES_STATUS_DATA: [StatusData; 6] = [
   StatusData::NONE,
   StatusData::StatusTrackerReset,
   StatusData::StatusTrackerError,
   StatusData::StatusSteamVRDisconnected,
   StatusData::StatusUnassignedHMD,
+  StatusData::StatusPublicNetwork,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -33,15 +34,17 @@ impl StatusData {
   pub const StatusTrackerError: Self = Self(2);
   pub const StatusSteamVRDisconnected: Self = Self(3);
   pub const StatusUnassignedHMD: Self = Self(4);
+  pub const StatusPublicNetwork: Self = Self(5);
 
   pub const ENUM_MIN: u8 = 0;
-  pub const ENUM_MAX: u8 = 4;
+  pub const ENUM_MAX: u8 = 5;
   pub const ENUM_VALUES: &'static [Self] = &[
     Self::NONE,
     Self::StatusTrackerReset,
     Self::StatusTrackerError,
     Self::StatusSteamVRDisconnected,
     Self::StatusUnassignedHMD,
+    Self::StatusPublicNetwork,
   ];
   /// Returns the variant's name or "" if unknown.
   pub fn variant_name(self) -> Option<&'static str> {
@@ -51,6 +54,7 @@ impl StatusData {
       Self::StatusTrackerError => Some("StatusTrackerError"),
       Self::StatusSteamVRDisconnected => Some("StatusSteamVRDisconnected"),
       Self::StatusUnassignedHMD => Some("StatusUnassignedHMD"),
+      Self::StatusPublicNetwork => Some("StatusPublicNetwork"),
       _ => None,
     }
   }

protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs

@@ -140,6 +140,21 @@ impl<'a> StatusMessage<'a> {
     }
   }
 
+  #[inline]
+  #[allow(non_snake_case)]
+  pub fn data_as_status_public_network(&self) -> Option<StatusPublicNetwork<'a>> {
+    if self.data_type() == StatusData::StatusPublicNetwork {
+      self.data().map(|t| {
+       // Safety:
+       // Created from a valid Table for this object
+       // Which contains a valid union in this slot
+       unsafe { StatusPublicNetwork::init_from_table(t) }
+     })
+    } else {
+      None
+    }
+  }
+
 }
 
 impl flatbuffers::Verifiable for StatusMessage<'_> {
@@ -157,6 +172,7 @@ impl flatbuffers::Verifiable for StatusMessage<'_> {
           StatusData::StatusTrackerError => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusTrackerError>>("StatusData::StatusTrackerError", pos),
           StatusData::StatusSteamVRDisconnected => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusSteamVRDisconnected>>("StatusData::StatusSteamVRDisconnected", pos),
           StatusData::StatusUnassignedHMD => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusUnassignedHMD>>("StatusData::StatusUnassignedHMD", pos),
+          StatusData::StatusPublicNetwork => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusPublicNetwork>>("StatusData::StatusPublicNetwork", pos),
           _ => Ok(()),
         }
      })?
@@ -253,6 +269,13 @@ impl core::fmt::Debug for StatusMessage<'_> {
             ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.")
           }
         },
+        StatusData::StatusPublicNetwork => {
+          if let Some(x) = self.data_as_status_public_network() {
+            ds.field("data", &x)
+          } else {
+            ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.")
+          }
+        },
         _ => {
           let x: Option<()> = None;
           ds.field("data", &x)