swift-protobuf/Reference/SwiftProtobufPluginLibraryTests/pluginlib_descriptor_test.pb.swift

// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: pluginlib_descriptor_test.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/apple/swift-protobuf/

// Protos/pluginlib_descriptor_test.proto - test proto
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
// -----------------------------------------------------------------------------
///
/// Test proto for Tests/SwiftProtobufPluginLibraryTests/Test_Descriptor.swift
///
// -----------------------------------------------------------------------------

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
}

enum SDTTopLevelEnum: SwiftProtobuf.Enum {
  typealias RawValue = Int
  case valueZero // = 0
  case valueOne // = 1
  case valueTwo // = 2

  init() {
    self = .valueZero
  }

  init?(rawValue: Int) {
    switch rawValue {
    case 0: self = .valueZero
    case 1: self = .valueOne
    case 2: self = .valueTwo
    default: return nil
    }
  }

  var rawValue: Int {
    switch self {
    case .valueZero: return 0
    case .valueOne: return 1
    case .valueTwo: return 2
    }
  }

}

#if swift(>=4.2)

extension SDTTopLevelEnum: CaseIterable {
  // Support synthesized by the compiler.
}

#endif  // swift(>=4.2)

struct SDTTopLevelMessage {
  // 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.

  var field1: String {
    get {return _storage._field1 ?? String()}
    set {_uniqueStorage()._field1 = newValue}
  }
  /// Returns true if `field1` has been explicitly set.
  var hasField1: Bool {return _storage._field1 != nil}
  /// Clears the value of `field1`. Subsequent reads from it will return its default value.
  mutating func clearField1() {_uniqueStorage()._field1 = nil}

  var field2: Int32 {
    get {return _storage._field2 ?? 0}
    set {_uniqueStorage()._field2 = newValue}
  }
  /// Returns true if `field2` has been explicitly set.
  var hasField2: Bool {return _storage._field2 != nil}
  /// Clears the value of `field2`. Subsequent reads from it will return its default value.
  mutating func clearField2() {_uniqueStorage()._field2 = nil}

  var o: OneOf_O? {
    get {return _storage._o}
    set {_uniqueStorage()._o = newValue}
  }

  var field3: SDTTopLevelEnum {
    get {
      if case .field3(let v)? = _storage._o {return v}
      return .valueZero
    }
    set {_uniqueStorage()._o = .field3(newValue)}
  }

  var field4: SDTTopLevelMessage.SubEnum {
    get {
      if case .field4(let v)? = _storage._o {return v}
      return .subValue0
    }
    set {_uniqueStorage()._o = .field4(newValue)}
  }

  var field5: SDTTopLevelMessage.SubMessage {
    get {
      if case .field5(let v)? = _storage._o {return v}
      return SDTTopLevelMessage.SubMessage()
    }
    set {_uniqueStorage()._o = .field5(newValue)}
  }

  var field6: SDTTopLevelMessage2 {
    get {
      if case .field6(let v)? = _storage._o {return v}
      return SDTTopLevelMessage2()
    }
    set {_uniqueStorage()._o = .field6(newValue)}
  }

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum OneOf_O: Equatable {
    case field3(SDTTopLevelEnum)
    case field4(SDTTopLevelMessage.SubEnum)
    case field5(SDTTopLevelMessage.SubMessage)
    case field6(SDTTopLevelMessage2)

  #if !swift(>=4.1)
    static func ==(lhs: SDTTopLevelMessage.OneOf_O, rhs: SDTTopLevelMessage.OneOf_O) -> 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 (.field3, .field3): return {
        guard case .field3(let l) = lhs, case .field3(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.field4, .field4): return {
        guard case .field4(let l) = lhs, case .field4(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.field5, .field5): return {
        guard case .field5(let l) = lhs, case .field5(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.field6, .field6): return {
        guard case .field6(let l) = lhs, case .field6(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      default: return false
      }
    }
  #endif
  }

  enum SubEnum: SwiftProtobuf.Enum {
    typealias RawValue = Int
    case subValue0 // = 0
    case subValue1 // = 1
    case subValue2 // = 2

    init() {
      self = .subValue0
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .subValue0
      case 1: self = .subValue1
      case 2: self = .subValue2
      default: return nil
      }
    }

    var rawValue: Int {
      switch self {
      case .subValue0: return 0
      case .subValue1: return 1
      case .subValue2: return 2
      }
    }

  }

  struct SubMessage {
    // 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.

    var field1: Int32 {
      get {return _storage._field1 ?? 0}
      set {_uniqueStorage()._field1 = newValue}
    }
    /// Returns true if `field1` has been explicitly set.
    var hasField1: Bool {return _storage._field1 != nil}
    /// Clears the value of `field1`. Subsequent reads from it will return its default value.
    mutating func clearField1() {_uniqueStorage()._field1 = nil}

    var field2: String {
      get {return _storage._field2 ?? String()}
      set {_uniqueStorage()._field2 = newValue}
    }
    /// Returns true if `field2` has been explicitly set.
    var hasField2: Bool {return _storage._field2 != nil}
    /// Clears the value of `field2`. Subsequent reads from it will return its default value.
    mutating func clearField2() {_uniqueStorage()._field2 = nil}

    var field3: SDTTopLevelMessage.SubMessage {
      get {return _storage._field3 ?? SDTTopLevelMessage.SubMessage()}
      set {_uniqueStorage()._field3 = newValue}
    }
    /// Returns true if `field3` has been explicitly set.
    var hasField3: Bool {return _storage._field3 != nil}
    /// Clears the value of `field3`. Subsequent reads from it will return its default value.
    mutating func clearField3() {_uniqueStorage()._field3 = nil}

    var unknownFields = SwiftProtobuf.UnknownStorage()

    init() {}

    fileprivate var _storage = _StorageClass.defaultInstance
  }

  init() {}

  fileprivate var _storage = _StorageClass.defaultInstance
}

#if swift(>=4.2)

extension SDTTopLevelMessage.SubEnum: CaseIterable {
  // Support synthesized by the compiler.
}

#endif  // swift(>=4.2)

struct SDTTopLevelMessage2 {
  // 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.

  var left: SDTTopLevelMessage {
    get {return _storage._left ?? SDTTopLevelMessage()}
    set {_uniqueStorage()._left = newValue}
  }
  /// Returns true if `left` has been explicitly set.
  var hasLeft: Bool {return _storage._left != nil}
  /// Clears the value of `left`. Subsequent reads from it will return its default value.
  mutating func clearLeft() {_uniqueStorage()._left = nil}

  var right: SDTTopLevelMessage2 {
    get {return _storage._right ?? SDTTopLevelMessage2()}
    set {_uniqueStorage()._right = newValue}
  }
  /// Returns true if `right` has been explicitly set.
  var hasRight: Bool {return _storage._right != nil}
  /// Clears the value of `right`. Subsequent reads from it will return its default value.
  mutating func clearRight() {_uniqueStorage()._right = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _storage = _StorageClass.defaultInstance
}

struct SDTExternalRefs {
  // 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.

  var desc: SwiftProtobuf.Google_Protobuf_DescriptorProto {
    get {return _desc ?? SwiftProtobuf.Google_Protobuf_DescriptorProto()}
    set {_desc = newValue}
  }
  /// Returns true if `desc` has been explicitly set.
  var hasDesc: Bool {return self._desc != nil}
  /// Clears the value of `desc`. Subsequent reads from it will return its default value.
  mutating func clearDesc() {self._desc = nil}

  var ver: Google_Protobuf_Compiler_Version {
    get {return _ver ?? Google_Protobuf_Compiler_Version()}
    set {_ver = newValue}
  }
  /// Returns true if `ver` has been explicitly set.
  var hasVer: Bool {return self._ver != nil}
  /// Clears the value of `ver`. Subsequent reads from it will return its default value.
  mutating func clearVer() {self._ver = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _desc: SwiftProtobuf.Google_Protobuf_DescriptorProto? = nil
  fileprivate var _ver: Google_Protobuf_Compiler_Version? = nil
}

struct SDTScoperForExt {
  // 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.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct SDTProto2MessageForPresence {
  // 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.

  var reqStrField: String {
    get {return _reqStrField ?? String()}
    set {_reqStrField = newValue}
  }
  /// Returns true if `reqStrField` has been explicitly set.
  var hasReqStrField: Bool {return self._reqStrField != nil}
  /// Clears the value of `reqStrField`. Subsequent reads from it will return its default value.
  mutating func clearReqStrField() {self._reqStrField = nil}

  var reqInt32Field: Int32 {
    get {return _reqInt32Field ?? 0}
    set {_reqInt32Field = newValue}
  }
  /// Returns true if `reqInt32Field` has been explicitly set.
  var hasReqInt32Field: Bool {return self._reqInt32Field != nil}
  /// Clears the value of `reqInt32Field`. Subsequent reads from it will return its default value.
  mutating func clearReqInt32Field() {self._reqInt32Field = nil}

  var reqEnumField: SDTTopLevelEnum {
    get {return _reqEnumField ?? .valueZero}
    set {_reqEnumField = newValue}
  }
  /// Returns true if `reqEnumField` has been explicitly set.
  var hasReqEnumField: Bool {return self._reqEnumField != nil}
  /// Clears the value of `reqEnumField`. Subsequent reads from it will return its default value.
  mutating func clearReqEnumField() {self._reqEnumField = nil}

  var reqMessageField: SDTTopLevelMessage {
    get {return _reqMessageField ?? SDTTopLevelMessage()}
    set {_reqMessageField = newValue}
  }
  /// Returns true if `reqMessageField` has been explicitly set.
  var hasReqMessageField: Bool {return self._reqMessageField != nil}
  /// Clears the value of `reqMessageField`. Subsequent reads from it will return its default value.
  mutating func clearReqMessageField() {self._reqMessageField = nil}

  var optStrField: String {
    get {return _optStrField ?? String()}
    set {_optStrField = newValue}
  }
  /// Returns true if `optStrField` has been explicitly set.
  var hasOptStrField: Bool {return self._optStrField != nil}
  /// Clears the value of `optStrField`. Subsequent reads from it will return its default value.
  mutating func clearOptStrField() {self._optStrField = nil}

  var optInt32Field: Int32 {
    get {return _optInt32Field ?? 0}
    set {_optInt32Field = newValue}
  }
  /// Returns true if `optInt32Field` has been explicitly set.
  var hasOptInt32Field: Bool {return self._optInt32Field != nil}
  /// Clears the value of `optInt32Field`. Subsequent reads from it will return its default value.
  mutating func clearOptInt32Field() {self._optInt32Field = nil}

  var optEnumField: SDTTopLevelEnum {
    get {return _optEnumField ?? .valueZero}
    set {_optEnumField = newValue}
  }
  /// Returns true if `optEnumField` has been explicitly set.
  var hasOptEnumField: Bool {return self._optEnumField != nil}
  /// Clears the value of `optEnumField`. Subsequent reads from it will return its default value.
  mutating func clearOptEnumField() {self._optEnumField = nil}

  var optMessageField: SDTTopLevelMessage {
    get {return _optMessageField ?? SDTTopLevelMessage()}
    set {_optMessageField = newValue}
  }
  /// Returns true if `optMessageField` has been explicitly set.
  var hasOptMessageField: Bool {return self._optMessageField != nil}
  /// Clears the value of `optMessageField`. Subsequent reads from it will return its default value.
  mutating func clearOptMessageField() {self._optMessageField = nil}

  var repeatStrField: [String] = []

  var repeatInt32Field: [Int32] = []

  var repeatEnumField: [SDTTopLevelEnum] = []

  var repeatMessageField: [SDTTopLevelMessage] = []

  var o: SDTProto2MessageForPresence.OneOf_O? = nil

  var oneofStrField: String {
    get {
      if case .oneofStrField(let v)? = o {return v}
      return String()
    }
    set {o = .oneofStrField(newValue)}
  }

  var oneofInt32Field: Int32 {
    get {
      if case .oneofInt32Field(let v)? = o {return v}
      return 0
    }
    set {o = .oneofInt32Field(newValue)}
  }

  var oneofEnumField: SDTTopLevelEnum {
    get {
      if case .oneofEnumField(let v)? = o {return v}
      return .valueZero
    }
    set {o = .oneofEnumField(newValue)}
  }

  var oneofMessageField: SDTTopLevelMessage {
    get {
      if case .oneofMessageField(let v)? = o {return v}
      return SDTTopLevelMessage()
    }
    set {o = .oneofMessageField(newValue)}
  }

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum OneOf_O: Equatable {
    case oneofStrField(String)
    case oneofInt32Field(Int32)
    case oneofEnumField(SDTTopLevelEnum)
    case oneofMessageField(SDTTopLevelMessage)

  #if !swift(>=4.1)
    static func ==(lhs: SDTProto2MessageForPresence.OneOf_O, rhs: SDTProto2MessageForPresence.OneOf_O) -> 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 (.oneofStrField, .oneofStrField): return {
        guard case .oneofStrField(let l) = lhs, case .oneofStrField(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.oneofInt32Field, .oneofInt32Field): return {
        guard case .oneofInt32Field(let l) = lhs, case .oneofInt32Field(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.oneofEnumField, .oneofEnumField): return {
        guard case .oneofEnumField(let l) = lhs, case .oneofEnumField(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.oneofMessageField, .oneofMessageField): return {
        guard case .oneofMessageField(let l) = lhs, case .oneofMessageField(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      default: return false
      }
    }
  #endif
  }

  init() {}

  fileprivate var _reqStrField: String? = nil
  fileprivate var _reqInt32Field: Int32? = nil
  fileprivate var _reqEnumField: SDTTopLevelEnum? = nil
  fileprivate var _reqMessageField: SDTTopLevelMessage? = nil
  fileprivate var _optStrField: String? = nil
  fileprivate var _optInt32Field: Int32? = nil
  fileprivate var _optEnumField: SDTTopLevelEnum? = nil
  fileprivate var _optMessageField: SDTTopLevelMessage? = nil
}

/// To check handling of extension ranges that are out of order.
struct SDTMsgExtensionRangeOrdering: SwiftProtobuf.ExtensibleMessage {
  // 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.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet()
}

/// To check handling of extension ranges that are out of order, have fields or
/// reserved things mix through them.
struct SDTMsgExtensionRangeOrderingWithFields: SwiftProtobuf.ExtensibleMessage {
  // 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.

  var field6: Int32 {
    get {return _field6 ?? 0}
    set {_field6 = newValue}
  }
  /// Returns true if `field6` has been explicitly set.
  var hasField6: Bool {return self._field6 != nil}
  /// Clears the value of `field6`. Subsequent reads from it will return its default value.
  mutating func clearField6() {self._field6 = nil}

  var field124: Int32 {
    get {return _field124 ?? 0}
    set {_field124 = newValue}
  }
  /// Returns true if `field124` has been explicitly set.
  var hasField124: Bool {return self._field124 != nil}
  /// Clears the value of `field124`. Subsequent reads from it will return its default value.
  mutating func clearField124() {self._field124 = nil}

  var field125: Int32 {
    get {return _field125 ?? 0}
    set {_field125 = newValue}
  }
  /// Returns true if `field125` has been explicitly set.
  var hasField125: Bool {return self._field125 != nil}
  /// Clears the value of `field125`. Subsequent reads from it will return its default value.
  mutating func clearField125() {self._field125 = nil}

  var field200: Int32 {
    get {return _field200 ?? 0}
    set {_field200 = newValue}
  }
  /// Returns true if `field200` has been explicitly set.
  var hasField200: Bool {return self._field200 != nil}
  /// Clears the value of `field200`. Subsequent reads from it will return its default value.
  mutating func clearField200() {self._field200 = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet()
  fileprivate var _field6: Int32? = nil
  fileprivate var _field124: Int32? = nil
  fileprivate var _field125: Int32? = nil
  fileprivate var _field200: Int32? = nil
}

/// Intermixed ranges and fields so help ensure no merge issues
struct SDTMsgExtensionRangeOrderingNoMerging: SwiftProtobuf.ExtensibleMessage {
  // 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.

  var field1: Int32 {
    get {return _field1 ?? 0}
    set {_field1 = newValue}
  }
  /// Returns true if `field1` has been explicitly set.
  var hasField1: Bool {return self._field1 != nil}
  /// Clears the value of `field1`. Subsequent reads from it will return its default value.
  mutating func clearField1() {self._field1 = nil}

  var field2: Int32 {
    get {return _field2 ?? 0}
    set {_field2 = newValue}
  }
  /// Returns true if `field2` has been explicitly set.
  var hasField2: Bool {return self._field2 != nil}
  /// Clears the value of `field2`. Subsequent reads from it will return its default value.
  mutating func clearField2() {self._field2 = nil}

  var field6: Int32 {
    get {return _field6 ?? 0}
    set {_field6 = newValue}
  }
  /// Returns true if `field6` has been explicitly set.
  var hasField6: Bool {return self._field6 != nil}
  /// Clears the value of `field6`. Subsequent reads from it will return its default value.
  mutating func clearField6() {self._field6 = nil}

  var field13: Int32 {
    get {return _field13 ?? 0}
    set {_field13 = newValue}
  }
  /// Returns true if `field13` has been explicitly set.
  var hasField13: Bool {return self._field13 != nil}
  /// Clears the value of `field13`. Subsequent reads from it will return its default value.
  mutating func clearField13() {self._field13 = nil}

  var field15: Int32 {
    get {return _field15 ?? 0}
    set {_field15 = newValue}
  }
  /// Returns true if `field15` has been explicitly set.
  var hasField15: Bool {return self._field15 != nil}
  /// Clears the value of `field15`. Subsequent reads from it will return its default value.
  mutating func clearField15() {self._field15 = nil}

  var field21: Int32 {
    get {return _field21 ?? 0}
    set {_field21 = newValue}
  }
  /// Returns true if `field21` has been explicitly set.
  var hasField21: Bool {return self._field21 != nil}
  /// Clears the value of `field21`. Subsequent reads from it will return its default value.
  mutating func clearField21() {self._field21 = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  var _protobuf_extensionFieldValues = SwiftProtobuf.ExtensionFieldValueSet()
  fileprivate var _field1: Int32? = nil
  fileprivate var _field2: Int32? = nil
  fileprivate var _field6: Int32? = nil
  fileprivate var _field13: Int32? = nil
  fileprivate var _field15: Int32? = nil
  fileprivate var _field21: Int32? = nil
}

#if swift(>=5.5) && canImport(_Concurrency)
extension SDTTopLevelEnum: @unchecked Sendable {}
extension SDTTopLevelMessage: @unchecked Sendable {}
extension SDTTopLevelMessage.OneOf_O: @unchecked Sendable {}
extension SDTTopLevelMessage.SubEnum: @unchecked Sendable {}
extension SDTTopLevelMessage.SubMessage: @unchecked Sendable {}
extension SDTTopLevelMessage2: @unchecked Sendable {}
extension SDTExternalRefs: @unchecked Sendable {}
extension SDTScoperForExt: @unchecked Sendable {}
extension SDTProto2MessageForPresence: @unchecked Sendable {}
extension SDTProto2MessageForPresence.OneOf_O: @unchecked Sendable {}
extension SDTMsgExtensionRangeOrdering: @unchecked Sendable {}
extension SDTMsgExtensionRangeOrderingWithFields: @unchecked Sendable {}
extension SDTMsgExtensionRangeOrderingNoMerging: @unchecked Sendable {}
#endif  // swift(>=5.5) && canImport(_Concurrency)

// MARK: - Extension support defined in pluginlib_descriptor_test.proto.

// MARK: - Extension Properties

// Swift Extensions on the exteneded Messages to add easy access to the declared
// extension fields. The names are based on the extension field name from the proto
// declaration. To avoid naming collisions, the names are prefixed with the name of
// the scope where the extend directive occurs.

extension SwiftProtobuf.Google_Protobuf_FieldOptions {

  var SDTextStr: String {
    get {return getExtensionValue(ext: SDTExtensions_ext_str) ?? String()}
    set {setExtensionValue(ext: SDTExtensions_ext_str, value: newValue)}
  }
  /// Returns true if extension `SDTExtensions_ext_str`
  /// has been explicitly set.
  var hasSDTextStr: Bool {
    return hasExtensionValue(ext: SDTExtensions_ext_str)
  }
  /// Clears the value of extension `SDTExtensions_ext_str`.
  /// Subsequent reads from it will return its default value.
  mutating func clearSDTextStr() {
    clearExtensionValue(ext: SDTExtensions_ext_str)
  }
}

extension SwiftProtobuf.Google_Protobuf_MessageOptions {

  var SDTScoperForExt_extEnum: SDTTopLevelEnum {
    get {return getExtensionValue(ext: SDTScoperForExt.Extensions.ext_enum) ?? .valueZero}
    set {setExtensionValue(ext: SDTScoperForExt.Extensions.ext_enum, value: newValue)}
  }
  /// Returns true if extension `SDTScoperForExt.Extensions.ext_enum`
  /// has been explicitly set.
  var hasSDTScoperForExt_extEnum: Bool {
    return hasExtensionValue(ext: SDTScoperForExt.Extensions.ext_enum)
  }
  /// Clears the value of extension `SDTScoperForExt.Extensions.ext_enum`.
  /// Subsequent reads from it will return its default value.
  mutating func clearSDTScoperForExt_extEnum() {
    clearExtensionValue(ext: SDTScoperForExt.Extensions.ext_enum)
  }

  var SDTScoperForExt_extMsg: SDTTopLevelMessage2 {
    get {return getExtensionValue(ext: SDTScoperForExt.Extensions.ext_msg) ?? SDTTopLevelMessage2()}
    set {setExtensionValue(ext: SDTScoperForExt.Extensions.ext_msg, value: newValue)}
  }
  /// Returns true if extension `SDTScoperForExt.Extensions.ext_msg`
  /// has been explicitly set.
  var hasSDTScoperForExt_extMsg: Bool {
    return hasExtensionValue(ext: SDTScoperForExt.Extensions.ext_msg)
  }
  /// Clears the value of extension `SDTScoperForExt.Extensions.ext_msg`.
  /// Subsequent reads from it will return its default value.
  mutating func clearSDTScoperForExt_extMsg() {
    clearExtensionValue(ext: SDTScoperForExt.Extensions.ext_msg)
  }

}

// MARK: - File's ExtensionMap: SDTPluginlibDescriptorTest_Extensions

/// A `SwiftProtobuf.SimpleExtensionMap` that includes all of the extensions defined by
/// this .proto file. It can be used any place an `SwiftProtobuf.ExtensionMap` is needed
/// in parsing, or it can be combined with other `SwiftProtobuf.SimpleExtensionMap`s to create
/// a larger `SwiftProtobuf.SimpleExtensionMap`.
let SDTPluginlibDescriptorTest_Extensions: SwiftProtobuf.SimpleExtensionMap = [
  SDTExtensions_ext_str,
  SDTScoperForExt.Extensions.ext_enum,
  SDTScoperForExt.Extensions.ext_msg
]

// Extension Objects - The only reason these might be needed is when manually
// constructing a `SimpleExtensionMap`, otherwise, use the above _Extension Properties_
// accessors for the extension fields on the messages directly.

let SDTExtensions_ext_str = SwiftProtobuf.MessageExtension<SwiftProtobuf.OptionalExtensionField<SwiftProtobuf.ProtobufString>, SwiftProtobuf.Google_Protobuf_FieldOptions>(
  _protobuf_fieldNumber: 90000,
  fieldName: "swift_descriptor_test.ext_str"
)

extension SDTScoperForExt {
  enum Extensions {
    static let ext_enum = SwiftProtobuf.MessageExtension<SwiftProtobuf.OptionalEnumExtensionField<SDTTopLevelEnum>, SwiftProtobuf.Google_Protobuf_MessageOptions>(
      _protobuf_fieldNumber: 99001,
      fieldName: "swift_descriptor_test.ScoperForExt.ext_enum"
    )

    static let ext_msg = SwiftProtobuf.MessageExtension<SwiftProtobuf.OptionalMessageExtensionField<SDTTopLevelMessage2>, SwiftProtobuf.Google_Protobuf_MessageOptions>(
      _protobuf_fieldNumber: 99002,
      fieldName: "swift_descriptor_test.ScoperForExt.ext_msg"
    )
  }
}

// MARK: - Code below here is support for the SwiftProtobuf runtime.

fileprivate let _protobuf_package = "swift_descriptor_test"

extension SDTTopLevelEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "VALUE_ZERO"),
    1: .same(proto: "VALUE_ONE"),
    2: .same(proto: "VALUE_TWO"),
  ]
}

extension SDTTopLevelMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".TopLevelMessage"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "field1"),
    2: .same(proto: "field2"),
    3: .same(proto: "field3"),
    4: .same(proto: "field4"),
    5: .same(proto: "field5"),
    6: .same(proto: "field6"),
  ]

  fileprivate class _StorageClass {
    var _field1: String? = nil
    var _field2: Int32? = nil
    var _o: SDTTopLevelMessage.OneOf_O?

    #if swift(>=5.10)
      // This property is used as the initial default value for new instances of the type.
      // The type itself is protecting the reference to its storage via CoW semantics.
      // This will force a copy to be made of this reference when the first mutation occurs;
      // hence, it is safe to mark this as `nonisolated(unsafe)`.
      static nonisolated(unsafe) let defaultInstance = _StorageClass()
    #else
      static let defaultInstance = _StorageClass()
    #endif

    private init() {}

    init(copying source: _StorageClass) {
      _field1 = source._field1
      _field2 = source._field2
      _o = source._o
    }
  }

  fileprivate mutating func _uniqueStorage() -> _StorageClass {
    if !isKnownUniquelyReferenced(&_storage) {
      _storage = _StorageClass(copying: _storage)
    }
    return _storage
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    _ = _uniqueStorage()
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      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: &_storage._field1) }()
        case 2: try { try decoder.decodeSingularInt32Field(value: &_storage._field2) }()
        case 3: try {
          var v: SDTTopLevelEnum?
          try decoder.decodeSingularEnumField(value: &v)
          if let v = v {
            if _storage._o != nil {try decoder.handleConflictingOneOf()}
            _storage._o = .field3(v)
          }
        }()
        case 4: try {
          var v: SDTTopLevelMessage.SubEnum?
          try decoder.decodeSingularEnumField(value: &v)
          if let v = v {
            if _storage._o != nil {try decoder.handleConflictingOneOf()}
            _storage._o = .field4(v)
          }
        }()
        case 5: try {
          var v: SDTTopLevelMessage.SubMessage?
          var hadOneofValue = false
          if let current = _storage._o {
            hadOneofValue = true
            if case .field5(let m) = current {v = m}
          }
          try decoder.decodeSingularMessageField(value: &v)
          if let v = v {
            if hadOneofValue {try decoder.handleConflictingOneOf()}
            _storage._o = .field5(v)
          }
        }()
        case 6: try {
          var v: SDTTopLevelMessage2?
          var hadOneofValue = false
          if let current = _storage._o {
            hadOneofValue = true
            if case .field6(let m) = current {v = m}
          }
          try decoder.decodeSingularMessageField(value: &v)
          if let v = v {
            if hadOneofValue {try decoder.handleConflictingOneOf()}
            _storage._o = .field6(v)
          }
        }()
        default: break
        }
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      // 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
      try { if let v = _storage._field1 {
        try visitor.visitSingularStringField(value: v, fieldNumber: 1)
      } }()
      try { if let v = _storage._field2 {
        try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
      } }()
      switch _storage._o {
      case .field3?: try {
        guard case .field3(let v)? = _storage._o else { preconditionFailure() }
        try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
      }()
      case .field4?: try {
        guard case .field4(let v)? = _storage._o else { preconditionFailure() }
        try visitor.visitSingularEnumField(value: v, fieldNumber: 4)
      }()
      case .field5?: try {
        guard case .field5(let v)? = _storage._o else { preconditionFailure() }
        try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
      }()
      case .field6?: try {
        guard case .field6(let v)? = _storage._o else { preconditionFailure() }
        try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
      }()
      case nil: break
      }
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTTopLevelMessage, rhs: SDTTopLevelMessage) -> Bool {
    if lhs._storage !== rhs._storage {
      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
        let _storage = _args.0
        let rhs_storage = _args.1
        if _storage._field1 != rhs_storage._field1 {return false}
        if _storage._field2 != rhs_storage._field2 {return false}
        if _storage._o != rhs_storage._o {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTTopLevelMessage.SubEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "SUB_VALUE_0"),
    1: .same(proto: "SUB_VALUE_1"),
    2: .same(proto: "SUB_VALUE_2"),
  ]
}

extension SDTTopLevelMessage.SubMessage: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = SDTTopLevelMessage.protoMessageName + ".SubMessage"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "field1"),
    2: .same(proto: "field2"),
    3: .same(proto: "field3"),
  ]

  fileprivate class _StorageClass {
    var _field1: Int32? = nil
    var _field2: String? = nil
    var _field3: SDTTopLevelMessage.SubMessage? = nil

    #if swift(>=5.10)
      // This property is used as the initial default value for new instances of the type.
      // The type itself is protecting the reference to its storage via CoW semantics.
      // This will force a copy to be made of this reference when the first mutation occurs;
      // hence, it is safe to mark this as `nonisolated(unsafe)`.
      static nonisolated(unsafe) let defaultInstance = _StorageClass()
    #else
      static let defaultInstance = _StorageClass()
    #endif

    private init() {}

    init(copying source: _StorageClass) {
      _field1 = source._field1
      _field2 = source._field2
      _field3 = source._field3
    }
  }

  fileprivate mutating func _uniqueStorage() -> _StorageClass {
    if !isKnownUniquelyReferenced(&_storage) {
      _storage = _StorageClass(copying: _storage)
    }
    return _storage
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    _ = _uniqueStorage()
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      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: &_storage._field1) }()
        case 2: try { try decoder.decodeSingularStringField(value: &_storage._field2) }()
        case 3: try { try decoder.decodeSingularMessageField(value: &_storage._field3) }()
        default: break
        }
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      // 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
      try { if let v = _storage._field1 {
        try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
      } }()
      try { if let v = _storage._field2 {
        try visitor.visitSingularStringField(value: v, fieldNumber: 2)
      } }()
      try { if let v = _storage._field3 {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
      } }()
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTTopLevelMessage.SubMessage, rhs: SDTTopLevelMessage.SubMessage) -> Bool {
    if lhs._storage !== rhs._storage {
      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
        let _storage = _args.0
        let rhs_storage = _args.1
        if _storage._field1 != rhs_storage._field1 {return false}
        if _storage._field2 != rhs_storage._field2 {return false}
        if _storage._field3 != rhs_storage._field3 {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTTopLevelMessage2: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".TopLevelMessage2"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "left"),
    2: .same(proto: "right"),
  ]

  fileprivate class _StorageClass {
    var _left: SDTTopLevelMessage? = nil
    var _right: SDTTopLevelMessage2? = nil

    #if swift(>=5.10)
      // This property is used as the initial default value for new instances of the type.
      // The type itself is protecting the reference to its storage via CoW semantics.
      // This will force a copy to be made of this reference when the first mutation occurs;
      // hence, it is safe to mark this as `nonisolated(unsafe)`.
      static nonisolated(unsafe) let defaultInstance = _StorageClass()
    #else
      static let defaultInstance = _StorageClass()
    #endif

    private init() {}

    init(copying source: _StorageClass) {
      _left = source._left
      _right = source._right
    }
  }

  fileprivate mutating func _uniqueStorage() -> _StorageClass {
    if !isKnownUniquelyReferenced(&_storage) {
      _storage = _StorageClass(copying: _storage)
    }
    return _storage
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    _ = _uniqueStorage()
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      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.decodeSingularMessageField(value: &_storage._left) }()
        case 2: try { try decoder.decodeSingularMessageField(value: &_storage._right) }()
        default: break
        }
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try withExtendedLifetime(_storage) { (_storage: _StorageClass) in
      // 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
      try { if let v = _storage._left {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
      } }()
      try { if let v = _storage._right {
        try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
      } }()
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTTopLevelMessage2, rhs: SDTTopLevelMessage2) -> Bool {
    if lhs._storage !== rhs._storage {
      let storagesAreEqual: Bool = withExtendedLifetime((lhs._storage, rhs._storage)) { (_args: (_StorageClass, _StorageClass)) in
        let _storage = _args.0
        let rhs_storage = _args.1
        if _storage._left != rhs_storage._left {return false}
        if _storage._right != rhs_storage._right {return false}
        return true
      }
      if !storagesAreEqual {return false}
    }
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTExternalRefs: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ExternalRefs"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "desc"),
    2: .same(proto: "ver"),
  ]

  public var isInitialized: Bool {
    if let v = self._desc, !v.isInitialized {return false}
    return true
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(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.decodeSingularMessageField(value: &self._desc) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._ver) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(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
    try { if let v = self._desc {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._ver {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTExternalRefs, rhs: SDTExternalRefs) -> Bool {
    if lhs._desc != rhs._desc {return false}
    if lhs._ver != rhs._ver {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTScoperForExt: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ScoperForExt"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTScoperForExt, rhs: SDTScoperForExt) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTProto2MessageForPresence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Proto2MessageForPresence"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .standard(proto: "req_str_field"),
    2: .standard(proto: "req_int32_field"),
    3: .standard(proto: "req_enum_field"),
    4: .standard(proto: "req_message_field"),
    11: .standard(proto: "opt_str_field"),
    12: .standard(proto: "opt_int32_field"),
    13: .standard(proto: "opt_enum_field"),
    14: .standard(proto: "opt_message_field"),
    21: .standard(proto: "repeat_str_field"),
    22: .standard(proto: "repeat_int32_field"),
    23: .standard(proto: "repeat_enum_field"),
    24: .standard(proto: "repeat_message_field"),
    31: .standard(proto: "oneof_str_field"),
    32: .standard(proto: "oneof_int32_field"),
    33: .standard(proto: "oneof_enum_field"),
    34: .standard(proto: "oneof_message_field"),
  ]

  public var isInitialized: Bool {
    if self._reqStrField == nil {return false}
    if self._reqInt32Field == nil {return false}
    if self._reqEnumField == nil {return false}
    if self._reqMessageField == nil {return false}
    return true
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(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._reqStrField) }()
      case 2: try { try decoder.decodeSingularInt32Field(value: &self._reqInt32Field) }()
      case 3: try { try decoder.decodeSingularEnumField(value: &self._reqEnumField) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._reqMessageField) }()
      case 11: try { try decoder.decodeSingularStringField(value: &self._optStrField) }()
      case 12: try { try decoder.decodeSingularInt32Field(value: &self._optInt32Field) }()
      case 13: try { try decoder.decodeSingularEnumField(value: &self._optEnumField) }()
      case 14: try { try decoder.decodeSingularMessageField(value: &self._optMessageField) }()
      case 21: try { try decoder.decodeRepeatedStringField(value: &self.repeatStrField) }()
      case 22: try { try decoder.decodeRepeatedInt32Field(value: &self.repeatInt32Field) }()
      case 23: try { try decoder.decodeRepeatedEnumField(value: &self.repeatEnumField) }()
      case 24: try { try decoder.decodeRepeatedMessageField(value: &self.repeatMessageField) }()
      case 31: try {
        var v: String?
        try decoder.decodeSingularStringField(value: &v)
        if let v = v {
          if self.o != nil {try decoder.handleConflictingOneOf()}
          self.o = .oneofStrField(v)
        }
      }()
      case 32: try {
        var v: Int32?
        try decoder.decodeSingularInt32Field(value: &v)
        if let v = v {
          if self.o != nil {try decoder.handleConflictingOneOf()}
          self.o = .oneofInt32Field(v)
        }
      }()
      case 33: try {
        var v: SDTTopLevelEnum?
        try decoder.decodeSingularEnumField(value: &v)
        if let v = v {
          if self.o != nil {try decoder.handleConflictingOneOf()}
          self.o = .oneofEnumField(v)
        }
      }()
      case 34: try {
        var v: SDTTopLevelMessage?
        var hadOneofValue = false
        if let current = self.o {
          hadOneofValue = true
          if case .oneofMessageField(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {
          if hadOneofValue {try decoder.handleConflictingOneOf()}
          self.o = .oneofMessageField(v)
        }
      }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(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
    try { if let v = self._reqStrField {
      try visitor.visitSingularStringField(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._reqInt32Field {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
    } }()
    try { if let v = self._reqEnumField {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 3)
    } }()
    try { if let v = self._reqMessageField {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    } }()
    try { if let v = self._optStrField {
      try visitor.visitSingularStringField(value: v, fieldNumber: 11)
    } }()
    try { if let v = self._optInt32Field {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 12)
    } }()
    try { if let v = self._optEnumField {
      try visitor.visitSingularEnumField(value: v, fieldNumber: 13)
    } }()
    try { if let v = self._optMessageField {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
    } }()
    if !self.repeatStrField.isEmpty {
      try visitor.visitRepeatedStringField(value: self.repeatStrField, fieldNumber: 21)
    }
    if !self.repeatInt32Field.isEmpty {
      try visitor.visitRepeatedInt32Field(value: self.repeatInt32Field, fieldNumber: 22)
    }
    if !self.repeatEnumField.isEmpty {
      try visitor.visitRepeatedEnumField(value: self.repeatEnumField, fieldNumber: 23)
    }
    if !self.repeatMessageField.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.repeatMessageField, fieldNumber: 24)
    }
    switch self.o {
    case .oneofStrField?: try {
      guard case .oneofStrField(let v)? = self.o else { preconditionFailure() }
      try visitor.visitSingularStringField(value: v, fieldNumber: 31)
    }()
    case .oneofInt32Field?: try {
      guard case .oneofInt32Field(let v)? = self.o else { preconditionFailure() }
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 32)
    }()
    case .oneofEnumField?: try {
      guard case .oneofEnumField(let v)? = self.o else { preconditionFailure() }
      try visitor.visitSingularEnumField(value: v, fieldNumber: 33)
    }()
    case .oneofMessageField?: try {
      guard case .oneofMessageField(let v)? = self.o else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 34)
    }()
    case nil: break
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTProto2MessageForPresence, rhs: SDTProto2MessageForPresence) -> Bool {
    if lhs._reqStrField != rhs._reqStrField {return false}
    if lhs._reqInt32Field != rhs._reqInt32Field {return false}
    if lhs._reqEnumField != rhs._reqEnumField {return false}
    if lhs._reqMessageField != rhs._reqMessageField {return false}
    if lhs._optStrField != rhs._optStrField {return false}
    if lhs._optInt32Field != rhs._optInt32Field {return false}
    if lhs._optEnumField != rhs._optEnumField {return false}
    if lhs._optMessageField != rhs._optMessageField {return false}
    if lhs.repeatStrField != rhs.repeatStrField {return false}
    if lhs.repeatInt32Field != rhs.repeatInt32Field {return false}
    if lhs.repeatEnumField != rhs.repeatEnumField {return false}
    if lhs.repeatMessageField != rhs.repeatMessageField {return false}
    if lhs.o != rhs.o {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SDTMsgExtensionRangeOrdering: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrdering"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  public var isInitialized: Bool {
    if !_protobuf_extensionFieldValues.isInitialized {return false}
    return true
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(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..<5, 7, 9, 100..<121, 126..<131:
        try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SDTMsgExtensionRangeOrdering.self, fieldNumber: fieldNumber) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 131)
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTMsgExtensionRangeOrdering, rhs: SDTMsgExtensionRangeOrdering) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false}
    return true
  }
}

extension SDTMsgExtensionRangeOrderingWithFields: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrderingWithFields"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    6: .same(proto: "field6"),
    124: .same(proto: "field124"),
    125: .same(proto: "field125"),
    200: .same(proto: "field200"),
  ]

  public var isInitialized: Bool {
    if !_protobuf_extensionFieldValues.isInitialized {return false}
    return true
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(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 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }()
      case 124: try { try decoder.decodeSingularInt32Field(value: &self._field124) }()
      case 125: try { try decoder.decodeSingularInt32Field(value: &self._field125) }()
      case 200: try { try decoder.decodeSingularInt32Field(value: &self._field200) }()
      case 1..<5, 7, 9, 100..<121, 126..<131:
        try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SDTMsgExtensionRangeOrderingWithFields.self, fieldNumber: fieldNumber) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(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
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 1, end: 5)
    try { if let v = self._field6 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 6)
    } }()
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 7, end: 121)
    try { if let v = self._field124 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 124)
    } }()
    try { if let v = self._field125 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 125)
    } }()
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 126, end: 131)
    try { if let v = self._field200 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 200)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTMsgExtensionRangeOrderingWithFields, rhs: SDTMsgExtensionRangeOrderingWithFields) -> Bool {
    if lhs._field6 != rhs._field6 {return false}
    if lhs._field124 != rhs._field124 {return false}
    if lhs._field125 != rhs._field125 {return false}
    if lhs._field200 != rhs._field200 {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false}
    return true
  }
}

extension SDTMsgExtensionRangeOrderingNoMerging: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".MsgExtensionRangeOrderingNoMerging"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "field1"),
    2: .same(proto: "field2"),
    6: .same(proto: "field6"),
    13: .same(proto: "field13"),
    15: .same(proto: "field15"),
    21: .same(proto: "field21"),
  ]

  public var isInitialized: Bool {
    if !_protobuf_extensionFieldValues.isInitialized {return false}
    return true
  }

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(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._field1) }()
      case 2: try { try decoder.decodeSingularInt32Field(value: &self._field2) }()
      case 6: try { try decoder.decodeSingularInt32Field(value: &self._field6) }()
      case 13: try { try decoder.decodeSingularInt32Field(value: &self._field13) }()
      case 15: try { try decoder.decodeSingularInt32Field(value: &self._field15) }()
      case 21: try { try decoder.decodeSingularInt32Field(value: &self._field21) }()
      case 3..<6, 7..<13, 16..<21:
        try { try decoder.decodeExtensionField(values: &_protobuf_extensionFieldValues, messageType: SDTMsgExtensionRangeOrderingNoMerging.self, fieldNumber: fieldNumber) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(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
    try { if let v = self._field1 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 1)
    } }()
    try { if let v = self._field2 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 2)
    } }()
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 3, end: 6)
    try { if let v = self._field6 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 6)
    } }()
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 7, end: 13)
    try { if let v = self._field13 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 13)
    } }()
    try { if let v = self._field15 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 15)
    } }()
    try visitor.visitExtensionFields(fields: _protobuf_extensionFieldValues, start: 16, end: 21)
    try { if let v = self._field21 {
      try visitor.visitSingularInt32Field(value: v, fieldNumber: 21)
    } }()
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SDTMsgExtensionRangeOrderingNoMerging, rhs: SDTMsgExtensionRangeOrderingNoMerging) -> Bool {
    if lhs._field1 != rhs._field1 {return false}
    if lhs._field2 != rhs._field2 {return false}
    if lhs._field6 != rhs._field6 {return false}
    if lhs._field13 != rhs._field13 {return false}
    if lhs._field15 != rhs._field15 {return false}
    if lhs._field21 != rhs._field21 {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    if lhs._protobuf_extensionFieldValues != rhs._protobuf_extensionFieldValues {return false}
    return true
  }
}