// DO NOT EDIT. // swift-format-ignore-file // // Generated by the Swift generator plugin for the protocol buffer compiler. // Source: config.proto // // For information on using the generated types, please see the documentation: // https://github.com/apple/swift-protobuf/ import Foundation import SwiftProtobuf // If the compiler emits an error on this type, it is because this file // was generated by a version of the `protoc` Swift plug-in that is // incompatible with the version of SwiftProtobuf to which you are linking. // Please ensure that you are building against the same version of the API // that was used to generate this file. fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck { struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {} typealias Version = _2 } struct Config { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// TODO: REPLACE var payloadVariant: Config.OneOf_PayloadVariant? = nil /// /// TODO: REPLACE var device: Config.DeviceConfig { get { if case .device(let v)? = payloadVariant {return v} return Config.DeviceConfig() } set {payloadVariant = .device(newValue)} } /// /// TODO: REPLACE var position: Config.PositionConfig { get { if case .position(let v)? = payloadVariant {return v} return Config.PositionConfig() } set {payloadVariant = .position(newValue)} } /// /// TODO: REPLACE var power: Config.PowerConfig { get { if case .power(let v)? = payloadVariant {return v} return Config.PowerConfig() } set {payloadVariant = .power(newValue)} } /// /// TODO: REPLACE var wifi: Config.WiFiConfig { get { if case .wifi(let v)? = payloadVariant {return v} return Config.WiFiConfig() } set {payloadVariant = .wifi(newValue)} } /// /// TODO: REPLACE var display: Config.DisplayConfig { get { if case .display(let v)? = payloadVariant {return v} return Config.DisplayConfig() } set {payloadVariant = .display(newValue)} } /// /// TODO: REPLACE var lora: Config.LoRaConfig { get { if case .lora(let v)? = payloadVariant {return v} return Config.LoRaConfig() } set {payloadVariant = .lora(newValue)} } var unknownFields = SwiftProtobuf.UnknownStorage() /// /// TODO: REPLACE enum OneOf_PayloadVariant: Equatable { /// /// TODO: REPLACE case device(Config.DeviceConfig) /// /// TODO: REPLACE case position(Config.PositionConfig) /// /// TODO: REPLACE case power(Config.PowerConfig) /// /// TODO: REPLACE case wifi(Config.WiFiConfig) /// /// TODO: REPLACE case display(Config.DisplayConfig) /// /// TODO: REPLACE case lora(Config.LoRaConfig) #if !swift(>=4.1) static func ==(lhs: Config.OneOf_PayloadVariant, rhs: Config.OneOf_PayloadVariant) -> Bool { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch (lhs, rhs) { case (.device, .device): return { guard case .device(let l) = lhs, case .device(let r) = rhs else { preconditionFailure() } return l == r }() case (.position, .position): return { guard case .position(let l) = lhs, case .position(let r) = rhs else { preconditionFailure() } return l == r }() case (.power, .power): return { guard case .power(let l) = lhs, case .power(let r) = rhs else { preconditionFailure() } return l == r }() case (.wifi, .wifi): return { guard case .wifi(let l) = lhs, case .wifi(let r) = rhs else { preconditionFailure() } return l == r }() case (.display, .display): return { guard case .display(let l) = lhs, case .display(let r) = rhs else { preconditionFailure() } return l == r }() case (.lora, .lora): return { guard case .lora(let l) = lhs, case .lora(let r) = rhs else { preconditionFailure() } return l == r }() default: return false } } #endif } /// /// TODO: REPLACE struct DeviceConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// Sets the role of node var role: Config.DeviceConfig.Role = .client /// /// If set, this will disable the SerialConsole by not initilizing the StreamAPI var serialDisabled: Bool = false /// /// This setting is never saved to disk, but if set, all device settings will be returned to factory defaults. /// (Region, serial number etc... will be preserved) var factoryReset: Bool = false /// /// By default we turn off logging as soon as an API client connects (to keep shared serial link quiet). /// Set this to true to leave the debug log outputting even when API is active. var debugLogEnabled: Bool = false /// /// NTP server to use if WiFi is conneced, defaults to `0.pool.ntp.org` var ntpServer: String = String() var unknownFields = SwiftProtobuf.UnknownStorage() /// /// Defines the device's role on the Mesh network /// unset /// Behave normally. /// Router /// Functions as a router enum Role: SwiftProtobuf.Enum { typealias RawValue = Int /// /// Client device role case client // = 0 /// /// ClientMute device role /// This is like the client but packets will not hop over this node. Would be /// useful if you want to save power by not contributing to the mesh. case clientMute // = 1 /// /// Router device role. /// Uses an agressive algirithem for the flood networking so packets will /// prefer to be routed over this node. Also assume that this will be generally /// unattended and so will turn off the wifi/ble radio as well as the oled screen. case router // = 2 /// /// RouterClient device role /// Uses an agressive algirithem for the flood networking so packets will /// prefer to be routed over this node. Similiar power management as a regular /// client, so the RouterClient can be used as both a Router and a Client. Useful /// as a well placed base station that you could also use to send messages. case routerClient // = 3 case UNRECOGNIZED(Int) init() { self = .client } init?(rawValue: Int) { switch rawValue { case 0: self = .client case 1: self = .clientMute case 2: self = .router case 3: self = .routerClient default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { case .client: return 0 case .clientMute: return 1 case .router: return 2 case .routerClient: return 3 case .UNRECOGNIZED(let i): return i } } } init() {} } /// /// TODO: REPLACE struct PositionConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// We should send our position this often (but only if it has changed significantly) /// Defaults to 15 minutes var positionBroadcastSecs: UInt32 = 0 /// /// Disable adaptive position braoadcast, which is now the default. var positionBroadcastSmartDisabled: Bool = false /// /// If set, this node is at a fixed position. /// We will generate GPS position updates at the regular interval, but use whatever the last lat/lon/alt we have for the node. /// The lat/lon/alt can be set by an internal GPS or with the help of the app. var fixedPosition: Bool = false /// /// Should the GPS be disabled for this node? var gpsDisabled: Bool = false /// /// How often should we try to get GPS position (in seconds) /// or zero for the default of once every 30 seconds /// or a very large value (maxint) to update only once at boot. var gpsUpdateInterval: UInt32 = 0 /// /// How long should we try to get our position during each gps_update_interval attempt? (in seconds) /// Or if zero, use the default of 30 seconds. /// If we don't get a new gps fix in that time, the gps will be put into sleep until the next gps_update_rate /// window. var gpsAttemptTime: UInt32 = 0 /// /// Bit field of boolean configuration options for POSITION messages /// (bitwise OR of PositionFlags) var positionFlags: UInt32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() /// /// Bit field of boolean configuration options, indicating which optional /// fields to include when assembling POSITION messages /// Longitude and latitude are always included (also time if GPS-synced) /// NOTE: the more fields are included, the larger the message will be - /// leading to longer airtime and a higher risk of packet loss enum PositionFlags: SwiftProtobuf.Enum { typealias RawValue = Int /// /// Required for compilation case posUndefined // = 0 /// /// Include an altitude value (if available) case posAltitude // = 1 /// /// Altitude value is MSL case posAltMsl // = 2 /// /// Include geoidal separation case posGeoSep // = 4 /// /// Include the DOP value ; PDOP used by default, see below case posDop // = 8 /// /// If POS_DOP set, send separate HDOP / VDOP values instead of PDOP case posHvdop // = 16 /// /// Include number of "satellites in view" case posSatinview // = 32 /// /// Include a sequence number incremented per packet case posSeqNos // = 64 /// /// Include positional timestamp (from GPS solution) case posTimestamp // = 128 case UNRECOGNIZED(Int) init() { self = .posUndefined } init?(rawValue: Int) { switch rawValue { case 0: self = .posUndefined case 1: self = .posAltitude case 2: self = .posAltMsl case 4: self = .posGeoSep case 8: self = .posDop case 16: self = .posHvdop case 32: self = .posSatinview case 64: self = .posSeqNos case 128: self = .posTimestamp default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { case .posUndefined: return 0 case .posAltitude: return 1 case .posAltMsl: return 2 case .posGeoSep: return 4 case .posDop: return 8 case .posHvdop: return 16 case .posSatinview: return 32 case .posSeqNos: return 64 case .posTimestamp: return 128 case .UNRECOGNIZED(let i): return i } } } init() {} } /// /// TODO: REPLACE struct PowerConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// Sets the current of the battery charger var chargeCurrent: Config.PowerConfig.ChargeCurrent = .maunset /// /// If set, we are powered from a low-current source (i.e. solar), so even if it looks like we have power flowing in /// we should try to minimize power consumption as much as possible. /// YOU DO NOT NEED TO SET THIS IF YOU'VE set is_router (it is implied in that case). var isLowPower: Bool = false /// /// Circumvents the logic block for determining whether the device is powered or not. /// Useful for devices with finicky ADC issues on the battery sense pins. var isAlwaysPowered: Bool = false /// /// If non-zero, the device will fully power off this many seconds after external power is removed. var onBatteryShutdownAfterSecs: UInt32 = 0 /// /// If set to true, enable power saving features of the esp32 var isPowerSaving: Bool = false /// /// Ratio of voltage divider for battery pin eg. 3.20 (R1=100k, R2=220k) /// Overrides the ADC_MULTIPLIER defined in variant for battery voltage calculation. var adcMultiplierOverride: Float = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of 1 minute var waitBluetoothSecs: UInt32 = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of 15 minutes /// IMPORTANT NOTE FOR DEVICE CLIENTS: YOU MUST SEND SOME SORT OF PACKET TO THE PHONE AT LEAST THIS OFTEN OR THE DEVICE WILL DECIDE YOU ARE GONE! var phoneTimeoutSecs: UInt32 = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of two hours, MAXUINT for disabled var meshSdsTimeoutSecs: UInt32 = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of one year var sdsSecs: UInt32 = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of 3600 var lsSecs: UInt32 = 0 /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of 10 seconds var minWakeSecs: UInt32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() /// /// Sets the charge control current of devices with a battery charger that can be /// configured. This is passed into the axp power management chip like on the tbeam. enum ChargeCurrent: SwiftProtobuf.Enum { typealias RawValue = Int /// /// TODO: REPLACE case maunset // = 0 /// /// TODO: REPLACE case ma100 // = 1 /// /// TODO: REPLACE case ma190 // = 2 /// /// TODO: REPLACE case ma280 // = 3 /// /// TODO: REPLACE case ma360 // = 4 /// /// TODO: REPLACE case ma450 // = 5 /// /// TODO: REPLACE case ma550 // = 6 /// /// TODO: REPLACE case ma630 // = 7 /// /// TODO: REPLACE case ma700 // = 8 /// /// TODO: REPLACE case ma780 // = 9 /// /// TODO: REPLACE case ma880 // = 10 /// /// TODO: REPLACE case ma960 // = 11 /// /// TODO: REPLACE case ma1000 // = 12 /// /// TODO: REPLACE case ma1080 // = 13 /// /// TODO: REPLACE case ma1160 // = 14 /// /// TODO: REPLACE case ma1240 // = 15 /// /// TODO: REPLACE case ma1320 // = 16 case UNRECOGNIZED(Int) init() { self = .maunset } init?(rawValue: Int) { switch rawValue { case 0: self = .maunset case 1: self = .ma100 case 2: self = .ma190 case 3: self = .ma280 case 4: self = .ma360 case 5: self = .ma450 case 6: self = .ma550 case 7: self = .ma630 case 8: self = .ma700 case 9: self = .ma780 case 10: self = .ma880 case 11: self = .ma960 case 12: self = .ma1000 case 13: self = .ma1080 case 14: self = .ma1160 case 15: self = .ma1240 case 16: self = .ma1320 default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { case .maunset: return 0 case .ma100: return 1 case .ma190: return 2 case .ma280: return 3 case .ma360: return 4 case .ma450: return 5 case .ma550: return 6 case .ma630: return 7 case .ma700: return 8 case .ma780: return 9 case .ma880: return 10 case .ma960: return 11 case .ma1000: return 12 case .ma1080: return 13 case .ma1160: return 14 case .ma1240: return 15 case .ma1320: return 16 case .UNRECOGNIZED(let i): return i } } } init() {} } /// /// TODO: REPLACE struct WiFiConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// If set, this node will try to join the specified wifi network and /// acquire an address via DHCP var ssid: String = String() /// /// If set, will be use to authenticate to the named wifi var psk: String = String() /// /// If set, the node will operate as an AP (and DHCP server), otherwise it /// will be a station var apMode: Bool = false /// /// If set, the node AP will broadcast as a hidden SSID var apHidden: Bool = false var unknownFields = SwiftProtobuf.UnknownStorage() init() {} } /// /// TODO: REPLACE struct DisplayConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// Power management state machine option. /// See [power management](/docs/software/other/power) for details. /// 0 for default of one minute var screenOnSecs: UInt32 = 0 /// /// How the GPS coordinates are displayed on the OLED screen. var gpsFormat: Config.DisplayConfig.GpsCoordinateFormat = .gpsFormatDec /// /// Automatically toggles to the next page on the screen like a carousel, based the specified interval in seconds. /// Potentially useful for devices without user buttons. var autoScreenCarouselSecs: UInt32 = 0 var unknownFields = SwiftProtobuf.UnknownStorage() /// /// How the GPS coordinates are displayed on the OLED screen. enum GpsCoordinateFormat: SwiftProtobuf.Enum { typealias RawValue = Int /// /// GPS coordinates are displayed in the normal decimal degrees format: /// DD.DDDDDD DDD.DDDDDD case gpsFormatDec // = 0 /// /// GPS coordinates are displayed in the degrees minutes seconds format: /// DD°MM'SS"C DDD°MM'SS"C, where C is the compass point representing the locations quadrant case gpsFormatDms // = 1 /// /// GPS coordinates are displayed in Universal Transverse Mercator format: /// ZZB EEEEEE NNNNNNN, where Z is zone, B is band, E is easting, N is northing case gpsFormatUtm // = 2 /// /// GPS coordinates are displayed in Military Grid Reference System format: /// ZZB CD EEEEE NNNNN, where Z is zone, B is band, C is the east 100k square, D is the north 100k square, /// E is easting, N is northing case gpsFormatMgrs // = 3 /// /// GPS coordinates are displayed in Open Location Code (aka Plus Codes). case gpsFormatOlc // = 4 /// /// GPS coordinates are displayed in Ordnance Survey Grid Reference (the National Grid System of the UK). /// Format: AB EEEEE NNNNN, where A is the east 100k square, B is the north 100k square, E is the easting, /// N is the northing case gpsFormatOsgr // = 5 case UNRECOGNIZED(Int) init() { self = .gpsFormatDec } init?(rawValue: Int) { switch rawValue { case 0: self = .gpsFormatDec case 1: self = .gpsFormatDms case 2: self = .gpsFormatUtm case 3: self = .gpsFormatMgrs case 4: self = .gpsFormatOlc case 5: self = .gpsFormatOsgr default: self = .UNRECOGNIZED(rawValue) } } var rawValue: Int { switch self { case .gpsFormatDec: return 0 case .gpsFormatDms: return 1 case .gpsFormatUtm: return 2 case .gpsFormatMgrs: return 3 case .gpsFormatOlc: return 4 case .gpsFormatOsgr: return 5 case .UNRECOGNIZED(let i): return i } } } init() {} } /// /// TODO: REPLACE struct LoRaConfig { // SwiftProtobuf.Message conformance is added in an extension below. See the // `Message` and `Message+*Additions` files in the SwiftProtobuf library for // methods supported on all messages. /// /// If zero then, use default max legal continuous power (ie. something that won't /// burn out the radio hardware) /// In most cases you should use zero here. /// Units are in dBm. var txPower: Int32 = 0 /// /// Note: This is the 'old' mechanism for specifying channel parameters. /// Either modem_config or bandwidth/spreading/coding will be specified - NOT BOTH. /// As a heuristic: If bandwidth is specified, do not use modem_config. /// Because protobufs take ZERO space when the value is zero this works out nicely. /// This value is replaced by bandwidth/spread_factor/coding_rate. /// If you'd like to experiment with other options add them to MeshRadio.cpp in the device code. var modemPreset: Config.LoRaConfig.ModemPreset = .longFast /// /// Bandwidth in MHz /// Certain bandwidth numbers are 'special' and will be converted to the /// appropriate floating point value: 31 -> 31.25MHz var bandwidth: UInt32 = 0 /// /// A number from 7 to 12. /// Indicates number of chirps per symbol as 1<=4.2) extension Config.DeviceConfig.Role: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.DeviceConfig.Role] = [ .client, .clientMute, .router, .routerClient, ] } extension Config.PositionConfig.PositionFlags: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.PositionConfig.PositionFlags] = [ .posUndefined, .posAltitude, .posAltMsl, .posGeoSep, .posDop, .posHvdop, .posSatinview, .posSeqNos, .posTimestamp, ] } extension Config.PowerConfig.ChargeCurrent: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.PowerConfig.ChargeCurrent] = [ .maunset, .ma100, .ma190, .ma280, .ma360, .ma450, .ma550, .ma630, .ma700, .ma780, .ma880, .ma960, .ma1000, .ma1080, .ma1160, .ma1240, .ma1320, ] } extension Config.DisplayConfig.GpsCoordinateFormat: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.DisplayConfig.GpsCoordinateFormat] = [ .gpsFormatDec, .gpsFormatDms, .gpsFormatUtm, .gpsFormatMgrs, .gpsFormatOlc, .gpsFormatOsgr, ] } extension Config.LoRaConfig.RegionCode: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.LoRaConfig.RegionCode] = [ .unset, .us, .eu433, .eu868, .cn, .jp, .anz, .kr, .tw, .ru, .in, .nz865, .th, ] } extension Config.LoRaConfig.ModemPreset: CaseIterable { // The compiler won't synthesize support with the UNRECOGNIZED case. static var allCases: [Config.LoRaConfig.ModemPreset] = [ .longFast, .longSlow, .vlongSlow, .midSlow, .midFast, .shortSlow, .shortFast, ] } #endif // swift(>=4.2) #if swift(>=5.5) && canImport(_Concurrency) extension Config: @unchecked Sendable {} extension Config.OneOf_PayloadVariant: @unchecked Sendable {} extension Config.DeviceConfig: @unchecked Sendable {} extension Config.DeviceConfig.Role: @unchecked Sendable {} extension Config.PositionConfig: @unchecked Sendable {} extension Config.PositionConfig.PositionFlags: @unchecked Sendable {} extension Config.PowerConfig: @unchecked Sendable {} extension Config.PowerConfig.ChargeCurrent: @unchecked Sendable {} extension Config.WiFiConfig: @unchecked Sendable {} extension Config.DisplayConfig: @unchecked Sendable {} extension Config.DisplayConfig.GpsCoordinateFormat: @unchecked Sendable {} extension Config.LoRaConfig: @unchecked Sendable {} extension Config.LoRaConfig.RegionCode: @unchecked Sendable {} extension Config.LoRaConfig.ModemPreset: @unchecked Sendable {} #endif // swift(>=5.5) && canImport(_Concurrency) // MARK: - Code below here is support for the SwiftProtobuf runtime. extension Config: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = "Config" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "device"), 2: .same(proto: "position"), 3: .same(proto: "power"), 4: .same(proto: "wifi"), 5: .same(proto: "display"), 6: .same(proto: "lora"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { var v: Config.DeviceConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .device(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .device(v) } }() case 2: try { var v: Config.PositionConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .position(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .position(v) } }() case 3: try { var v: Config.PowerConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .power(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .power(v) } }() case 4: try { var v: Config.WiFiConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .wifi(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .wifi(v) } }() case 5: try { var v: Config.DisplayConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .display(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .display(v) } }() case 6: try { var v: Config.LoRaConfig? var hadOneofValue = false if let current = self.payloadVariant { hadOneofValue = true if case .lora(let m) = current {v = m} } try decoder.decodeSingularMessageField(value: &v) if let v = v { if hadOneofValue {try decoder.handleConflictingOneOf()} self.payloadVariant = .lora(v) } }() default: break } } } func traverse(visitor: inout V) throws { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every if/case branch local when no optimizations // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and // https://github.com/apple/swift-protobuf/issues/1182 switch self.payloadVariant { case .device?: try { guard case .device(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 1) }() case .position?: try { guard case .position(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 2) }() case .power?: try { guard case .power(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 3) }() case .wifi?: try { guard case .wifi(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 4) }() case .display?: try { guard case .display(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 5) }() case .lora?: try { guard case .lora(let v)? = self.payloadVariant else { preconditionFailure() } try visitor.visitSingularMessageField(value: v, fieldNumber: 6) }() case nil: break } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config, rhs: Config) -> Bool { if lhs.payloadVariant != rhs.payloadVariant {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.DeviceConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".DeviceConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "role"), 2: .standard(proto: "serial_disabled"), 3: .standard(proto: "factory_reset"), 4: .standard(proto: "debug_log_enabled"), 5: .standard(proto: "ntp_server"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularEnumField(value: &self.role) }() case 2: try { try decoder.decodeSingularBoolField(value: &self.serialDisabled) }() case 3: try { try decoder.decodeSingularBoolField(value: &self.factoryReset) }() case 4: try { try decoder.decodeSingularBoolField(value: &self.debugLogEnabled) }() case 5: try { try decoder.decodeSingularStringField(value: &self.ntpServer) }() default: break } } } func traverse(visitor: inout V) throws { if self.role != .client { try visitor.visitSingularEnumField(value: self.role, fieldNumber: 1) } if self.serialDisabled != false { try visitor.visitSingularBoolField(value: self.serialDisabled, fieldNumber: 2) } if self.factoryReset != false { try visitor.visitSingularBoolField(value: self.factoryReset, fieldNumber: 3) } if self.debugLogEnabled != false { try visitor.visitSingularBoolField(value: self.debugLogEnabled, fieldNumber: 4) } if !self.ntpServer.isEmpty { try visitor.visitSingularStringField(value: self.ntpServer, fieldNumber: 5) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.DeviceConfig, rhs: Config.DeviceConfig) -> Bool { if lhs.role != rhs.role {return false} if lhs.serialDisabled != rhs.serialDisabled {return false} if lhs.factoryReset != rhs.factoryReset {return false} if lhs.debugLogEnabled != rhs.debugLogEnabled {return false} if lhs.ntpServer != rhs.ntpServer {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.DeviceConfig.Role: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "Client"), 1: .same(proto: "ClientMute"), 2: .same(proto: "Router"), 3: .same(proto: "RouterClient"), ] } extension Config.PositionConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".PositionConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "position_broadcast_secs"), 2: .standard(proto: "position_broadcast_smart_disabled"), 3: .standard(proto: "fixed_position"), 5: .standard(proto: "gps_disabled"), 6: .standard(proto: "gps_update_interval"), 7: .standard(proto: "gps_attempt_time"), 10: .standard(proto: "position_flags"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularUInt32Field(value: &self.positionBroadcastSecs) }() case 2: try { try decoder.decodeSingularBoolField(value: &self.positionBroadcastSmartDisabled) }() case 3: try { try decoder.decodeSingularBoolField(value: &self.fixedPosition) }() case 5: try { try decoder.decodeSingularBoolField(value: &self.gpsDisabled) }() case 6: try { try decoder.decodeSingularUInt32Field(value: &self.gpsUpdateInterval) }() case 7: try { try decoder.decodeSingularUInt32Field(value: &self.gpsAttemptTime) }() case 10: try { try decoder.decodeSingularUInt32Field(value: &self.positionFlags) }() default: break } } } func traverse(visitor: inout V) throws { if self.positionBroadcastSecs != 0 { try visitor.visitSingularUInt32Field(value: self.positionBroadcastSecs, fieldNumber: 1) } if self.positionBroadcastSmartDisabled != false { try visitor.visitSingularBoolField(value: self.positionBroadcastSmartDisabled, fieldNumber: 2) } if self.fixedPosition != false { try visitor.visitSingularBoolField(value: self.fixedPosition, fieldNumber: 3) } if self.gpsDisabled != false { try visitor.visitSingularBoolField(value: self.gpsDisabled, fieldNumber: 5) } if self.gpsUpdateInterval != 0 { try visitor.visitSingularUInt32Field(value: self.gpsUpdateInterval, fieldNumber: 6) } if self.gpsAttemptTime != 0 { try visitor.visitSingularUInt32Field(value: self.gpsAttemptTime, fieldNumber: 7) } if self.positionFlags != 0 { try visitor.visitSingularUInt32Field(value: self.positionFlags, fieldNumber: 10) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.PositionConfig, rhs: Config.PositionConfig) -> Bool { if lhs.positionBroadcastSecs != rhs.positionBroadcastSecs {return false} if lhs.positionBroadcastSmartDisabled != rhs.positionBroadcastSmartDisabled {return false} if lhs.fixedPosition != rhs.fixedPosition {return false} if lhs.gpsDisabled != rhs.gpsDisabled {return false} if lhs.gpsUpdateInterval != rhs.gpsUpdateInterval {return false} if lhs.gpsAttemptTime != rhs.gpsAttemptTime {return false} if lhs.positionFlags != rhs.positionFlags {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.PositionConfig.PositionFlags: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "POS_UNDEFINED"), 1: .same(proto: "POS_ALTITUDE"), 2: .same(proto: "POS_ALT_MSL"), 4: .same(proto: "POS_GEO_SEP"), 8: .same(proto: "POS_DOP"), 16: .same(proto: "POS_HVDOP"), 32: .same(proto: "POS_SATINVIEW"), 64: .same(proto: "POS_SEQ_NOS"), 128: .same(proto: "POS_TIMESTAMP"), ] } extension Config.PowerConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".PowerConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "charge_current"), 2: .standard(proto: "is_low_power"), 3: .standard(proto: "is_always_powered"), 4: .standard(proto: "on_battery_shutdown_after_secs"), 5: .standard(proto: "is_power_saving"), 6: .standard(proto: "adc_multiplier_override"), 7: .standard(proto: "wait_bluetooth_secs"), 8: .standard(proto: "phone_timeout_secs"), 9: .standard(proto: "mesh_sds_timeout_secs"), 10: .standard(proto: "sds_secs"), 11: .standard(proto: "ls_secs"), 12: .standard(proto: "min_wake_secs"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularEnumField(value: &self.chargeCurrent) }() case 2: try { try decoder.decodeSingularBoolField(value: &self.isLowPower) }() case 3: try { try decoder.decodeSingularBoolField(value: &self.isAlwaysPowered) }() case 4: try { try decoder.decodeSingularUInt32Field(value: &self.onBatteryShutdownAfterSecs) }() case 5: try { try decoder.decodeSingularBoolField(value: &self.isPowerSaving) }() case 6: try { try decoder.decodeSingularFloatField(value: &self.adcMultiplierOverride) }() case 7: try { try decoder.decodeSingularUInt32Field(value: &self.waitBluetoothSecs) }() case 8: try { try decoder.decodeSingularUInt32Field(value: &self.phoneTimeoutSecs) }() case 9: try { try decoder.decodeSingularUInt32Field(value: &self.meshSdsTimeoutSecs) }() case 10: try { try decoder.decodeSingularUInt32Field(value: &self.sdsSecs) }() case 11: try { try decoder.decodeSingularUInt32Field(value: &self.lsSecs) }() case 12: try { try decoder.decodeSingularUInt32Field(value: &self.minWakeSecs) }() default: break } } } func traverse(visitor: inout V) throws { if self.chargeCurrent != .maunset { try visitor.visitSingularEnumField(value: self.chargeCurrent, fieldNumber: 1) } if self.isLowPower != false { try visitor.visitSingularBoolField(value: self.isLowPower, fieldNumber: 2) } if self.isAlwaysPowered != false { try visitor.visitSingularBoolField(value: self.isAlwaysPowered, fieldNumber: 3) } if self.onBatteryShutdownAfterSecs != 0 { try visitor.visitSingularUInt32Field(value: self.onBatteryShutdownAfterSecs, fieldNumber: 4) } if self.isPowerSaving != false { try visitor.visitSingularBoolField(value: self.isPowerSaving, fieldNumber: 5) } if self.adcMultiplierOverride != 0 { try visitor.visitSingularFloatField(value: self.adcMultiplierOverride, fieldNumber: 6) } if self.waitBluetoothSecs != 0 { try visitor.visitSingularUInt32Field(value: self.waitBluetoothSecs, fieldNumber: 7) } if self.phoneTimeoutSecs != 0 { try visitor.visitSingularUInt32Field(value: self.phoneTimeoutSecs, fieldNumber: 8) } if self.meshSdsTimeoutSecs != 0 { try visitor.visitSingularUInt32Field(value: self.meshSdsTimeoutSecs, fieldNumber: 9) } if self.sdsSecs != 0 { try visitor.visitSingularUInt32Field(value: self.sdsSecs, fieldNumber: 10) } if self.lsSecs != 0 { try visitor.visitSingularUInt32Field(value: self.lsSecs, fieldNumber: 11) } if self.minWakeSecs != 0 { try visitor.visitSingularUInt32Field(value: self.minWakeSecs, fieldNumber: 12) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.PowerConfig, rhs: Config.PowerConfig) -> Bool { if lhs.chargeCurrent != rhs.chargeCurrent {return false} if lhs.isLowPower != rhs.isLowPower {return false} if lhs.isAlwaysPowered != rhs.isAlwaysPowered {return false} if lhs.onBatteryShutdownAfterSecs != rhs.onBatteryShutdownAfterSecs {return false} if lhs.isPowerSaving != rhs.isPowerSaving {return false} if lhs.adcMultiplierOverride != rhs.adcMultiplierOverride {return false} if lhs.waitBluetoothSecs != rhs.waitBluetoothSecs {return false} if lhs.phoneTimeoutSecs != rhs.phoneTimeoutSecs {return false} if lhs.meshSdsTimeoutSecs != rhs.meshSdsTimeoutSecs {return false} if lhs.sdsSecs != rhs.sdsSecs {return false} if lhs.lsSecs != rhs.lsSecs {return false} if lhs.minWakeSecs != rhs.minWakeSecs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.PowerConfig.ChargeCurrent: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "MAUnset"), 1: .same(proto: "MA100"), 2: .same(proto: "MA190"), 3: .same(proto: "MA280"), 4: .same(proto: "MA360"), 5: .same(proto: "MA450"), 6: .same(proto: "MA550"), 7: .same(proto: "MA630"), 8: .same(proto: "MA700"), 9: .same(proto: "MA780"), 10: .same(proto: "MA880"), 11: .same(proto: "MA960"), 12: .same(proto: "MA1000"), 13: .same(proto: "MA1080"), 14: .same(proto: "MA1160"), 15: .same(proto: "MA1240"), 16: .same(proto: "MA1320"), ] } extension Config.WiFiConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".WiFiConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .same(proto: "ssid"), 2: .same(proto: "psk"), 3: .standard(proto: "ap_mode"), 4: .standard(proto: "ap_hidden"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularStringField(value: &self.ssid) }() case 2: try { try decoder.decodeSingularStringField(value: &self.psk) }() case 3: try { try decoder.decodeSingularBoolField(value: &self.apMode) }() case 4: try { try decoder.decodeSingularBoolField(value: &self.apHidden) }() default: break } } } func traverse(visitor: inout V) throws { if !self.ssid.isEmpty { try visitor.visitSingularStringField(value: self.ssid, fieldNumber: 1) } if !self.psk.isEmpty { try visitor.visitSingularStringField(value: self.psk, fieldNumber: 2) } if self.apMode != false { try visitor.visitSingularBoolField(value: self.apMode, fieldNumber: 3) } if self.apHidden != false { try visitor.visitSingularBoolField(value: self.apHidden, fieldNumber: 4) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.WiFiConfig, rhs: Config.WiFiConfig) -> Bool { if lhs.ssid != rhs.ssid {return false} if lhs.psk != rhs.psk {return false} if lhs.apMode != rhs.apMode {return false} if lhs.apHidden != rhs.apHidden {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.DisplayConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".DisplayConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "screen_on_secs"), 2: .standard(proto: "gps_format"), 3: .standard(proto: "auto_screen_carousel_secs"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularUInt32Field(value: &self.screenOnSecs) }() case 2: try { try decoder.decodeSingularEnumField(value: &self.gpsFormat) }() case 3: try { try decoder.decodeSingularUInt32Field(value: &self.autoScreenCarouselSecs) }() default: break } } } func traverse(visitor: inout V) throws { if self.screenOnSecs != 0 { try visitor.visitSingularUInt32Field(value: self.screenOnSecs, fieldNumber: 1) } if self.gpsFormat != .gpsFormatDec { try visitor.visitSingularEnumField(value: self.gpsFormat, fieldNumber: 2) } if self.autoScreenCarouselSecs != 0 { try visitor.visitSingularUInt32Field(value: self.autoScreenCarouselSecs, fieldNumber: 3) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.DisplayConfig, rhs: Config.DisplayConfig) -> Bool { if lhs.screenOnSecs != rhs.screenOnSecs {return false} if lhs.gpsFormat != rhs.gpsFormat {return false} if lhs.autoScreenCarouselSecs != rhs.autoScreenCarouselSecs {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.DisplayConfig.GpsCoordinateFormat: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "GpsFormatDec"), 1: .same(proto: "GpsFormatDMS"), 2: .same(proto: "GpsFormatUTM"), 3: .same(proto: "GpsFormatMGRS"), 4: .same(proto: "GpsFormatOLC"), 5: .same(proto: "GpsFormatOSGR"), ] } extension Config.LoRaConfig: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding { static let protoMessageName: String = Config.protoMessageName + ".LoRaConfig" static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 1: .standard(proto: "tx_power"), 2: .standard(proto: "modem_preset"), 3: .same(proto: "bandwidth"), 4: .standard(proto: "spread_factor"), 5: .standard(proto: "coding_rate"), 6: .standard(proto: "frequency_offset"), 7: .same(proto: "region"), 8: .standard(proto: "hop_limit"), 9: .standard(proto: "tx_disabled"), 103: .standard(proto: "ignore_incoming"), ] mutating func decodeMessage(decoder: inout D) throws { while let fieldNumber = try decoder.nextFieldNumber() { // The use of inline closures is to circumvent an issue where the compiler // allocates stack space for every case branch when no optimizations are // enabled. https://github.com/apple/swift-protobuf/issues/1034 switch fieldNumber { case 1: try { try decoder.decodeSingularInt32Field(value: &self.txPower) }() case 2: try { try decoder.decodeSingularEnumField(value: &self.modemPreset) }() case 3: try { try decoder.decodeSingularUInt32Field(value: &self.bandwidth) }() case 4: try { try decoder.decodeSingularUInt32Field(value: &self.spreadFactor) }() case 5: try { try decoder.decodeSingularUInt32Field(value: &self.codingRate) }() case 6: try { try decoder.decodeSingularFloatField(value: &self.frequencyOffset) }() case 7: try { try decoder.decodeSingularEnumField(value: &self.region) }() case 8: try { try decoder.decodeSingularUInt32Field(value: &self.hopLimit) }() case 9: try { try decoder.decodeSingularBoolField(value: &self.txDisabled) }() case 103: try { try decoder.decodeRepeatedUInt32Field(value: &self.ignoreIncoming) }() default: break } } } func traverse(visitor: inout V) throws { if self.txPower != 0 { try visitor.visitSingularInt32Field(value: self.txPower, fieldNumber: 1) } if self.modemPreset != .longFast { try visitor.visitSingularEnumField(value: self.modemPreset, fieldNumber: 2) } if self.bandwidth != 0 { try visitor.visitSingularUInt32Field(value: self.bandwidth, fieldNumber: 3) } if self.spreadFactor != 0 { try visitor.visitSingularUInt32Field(value: self.spreadFactor, fieldNumber: 4) } if self.codingRate != 0 { try visitor.visitSingularUInt32Field(value: self.codingRate, fieldNumber: 5) } if self.frequencyOffset != 0 { try visitor.visitSingularFloatField(value: self.frequencyOffset, fieldNumber: 6) } if self.region != .unset { try visitor.visitSingularEnumField(value: self.region, fieldNumber: 7) } if self.hopLimit != 0 { try visitor.visitSingularUInt32Field(value: self.hopLimit, fieldNumber: 8) } if self.txDisabled != false { try visitor.visitSingularBoolField(value: self.txDisabled, fieldNumber: 9) } if !self.ignoreIncoming.isEmpty { try visitor.visitPackedUInt32Field(value: self.ignoreIncoming, fieldNumber: 103) } try unknownFields.traverse(visitor: &visitor) } static func ==(lhs: Config.LoRaConfig, rhs: Config.LoRaConfig) -> Bool { if lhs.txPower != rhs.txPower {return false} if lhs.modemPreset != rhs.modemPreset {return false} if lhs.bandwidth != rhs.bandwidth {return false} if lhs.spreadFactor != rhs.spreadFactor {return false} if lhs.codingRate != rhs.codingRate {return false} if lhs.frequencyOffset != rhs.frequencyOffset {return false} if lhs.region != rhs.region {return false} if lhs.hopLimit != rhs.hopLimit {return false} if lhs.txDisabled != rhs.txDisabled {return false} if lhs.ignoreIncoming != rhs.ignoreIncoming {return false} if lhs.unknownFields != rhs.unknownFields {return false} return true } } extension Config.LoRaConfig.RegionCode: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "Unset"), 1: .same(proto: "US"), 2: .same(proto: "EU433"), 3: .same(proto: "EU868"), 4: .same(proto: "CN"), 5: .same(proto: "JP"), 6: .same(proto: "ANZ"), 7: .same(proto: "KR"), 8: .same(proto: "TW"), 9: .same(proto: "RU"), 10: .same(proto: "IN"), 11: .same(proto: "NZ865"), 12: .same(proto: "TH"), ] } extension Config.LoRaConfig.ModemPreset: SwiftProtobuf._ProtoNameProviding { static let _protobuf_nameMap: SwiftProtobuf._NameMap = [ 0: .same(proto: "LongFast"), 1: .same(proto: "LongSlow"), 2: .same(proto: "VLongSlow"), 3: .same(proto: "MidSlow"), 4: .same(proto: "MidFast"), 5: .same(proto: "ShortSlow"), 6: .same(proto: "ShortFast"), ] }